Can you think back on all that stuff you learned in high school algebra? Things like
a 2 b 2 = ( a b )*( a + b )
E = MC 2
Those letters are variables, essentially storage containers with names . Any time you see a variable, you are supposed to replace it with whatever is in the container. That's really all a "variable" is.
For example, if we take the first formula above, and store 5 in the variable a and 3 in the variable b , then when we access a we get 5 and when we access b we get 3; so we would read the formula as
5 2 3 2 = (5 3)*(5 + 3)
(which, if you are curious , works out to 25 9 = ( 2 )*(8), which is 16 = 16).
It is common in programming to want to use the contents of a variable inside a string of text; for example, if you have
"Hello $ name "
you probably want to replace the variable $name with its contents to create a new string of text. In computer programming, the act of replacing a variable with its contents to create a new string of text is called interpolating (which is not at all the same as turning someone over to the international police organization Interpol).
All computer programming makes heavy use of variables. There are two major things you do with variables: assign something to them (store information in the container) and interpolate themthat is, replace the variable(s) with the contents of the container(s).
In a shell script, you assign a value to a variable using the = operator. It copies the value on the right side into the variable on the left side. For example:
greeting="Top of the morning to you."
# Speed of light in furlongs/fortnight C=1802617500000
Variables are replaced with their contents (that is, interpolated) any time they appear in a command line with a $ in front of their name:
echo "Then he said: $greeting"
The following task creates a script that assigns a value to a variable and then interpolates it in a command line. This is commonly done to store an error or warning message in a variable so that it may be used in several places in the script. That way, if you want to change the message, you only have to change it in one place.
To assign a value to a variable and then interpolate it:
Edit a new script file. For example,
The first line is the same as before:
Enter some comments to explain what the script does:
# This script assigns values to variables # and then interpolates them.
line1="The queen , my lord, is dead."
line2="She should have died
Assigning a value to a variable in a Bourne shell script is very simple. You start the line with the variable name. This can be any combination of letters, numbers , and the underscore character, _ (for example, a variable named item_23_01 is fine). However, variable names may not begin with a number.
Right after the variable name you put an equals sign ( = ). Do not put any spaces before or after the = sign.
After the = sign comes the value that is stored in the variable. The value can be a number or text. If the value has spaces inside it, enclose the value in quotes.
Add another comment:
# Now interpolate the variables.
echo "SEYTON: $line1"
echo "MACBETH: $line2"
Interpolating a variable is simply a matter of using the variable name in a command line with $ added to the beginning of the variable name.
When the shell reads any command line, either one entered at a shell prompt or one found in a script, the first thing the shell does is interpolate variables that start with $ .
Figure 9.3 is a code listing of a script that assigns a value to a variable and then interpolates it, and Figure 9.4 shows the result of running the script.
Figure 9.3. Code listing of a script that assigns values to two variables and then interpolates them.
#!/bin/sh # This script assigns values to variables # and then interpolates them. line1="The queen, my lord, is dead." line2="She should have died hereafter." # Now interpolate the variables. echo "SEYTON: $seyton" echo "MACBETH: $macbeth"
Figure 9.4. Running the script that uses variables.
localhost:~ vanilla$ ./myscript.sh SEYTON: The queen, my lord, is dead. MACBETH: She should have died hereafter. localhost:~ vanilla
About Those Algebraic Equations
The first one we listed shows how to calculate the difference between two squared numbers. So the difference between 9 2 and 4 2 is (9 4) times (9 + 4). That is, 81 16 equals 5 times 13. Check it out. Works every time. Pretty cool, huh? For more, see "The Difference of 2 Squares" (www.mste.uiuc.edu/users/dildine/ sketches /Diff2sq.htm).
The second equation is Einstein 's famous formula expression of his special theory of relativity , that energy ( E ) is equal to mass ( M ) multiplied by the square of the velocity of light ( C ). That formula plus a lot of technology can get you global thermonuclear war if you are not careful. For more, see "Einstein Explains the Equivalence of Energy and Matter" (www.aip.org/history/einstein/voice1.htm).
If you want to include quotes in the value, then you escape the quotes with backslashes:
response="MACBETH: \"Liar and slave!\""
It is quite common to use the value of a variable inside the assignment of another variable. This is easy to do because the shell performs variable interpolation on all the variables in a line before executing the command at the start of a line.
To use a variable inside another variable:
first_name="Alexis" last_name="Pushkin" full_name="$first_name $last_name"
#!/bin/sh # Example of using a variable inside the value # assigned to another variable. directory="/Applications (Mac OS 9)" message="OS 9 applications are in \"$directory\"" directory="/Applications" echo "$message" message="OS X applications are in \"$directory\"" echo "$message"
localhost:~ vanilla$ ./newscript.sh OS 9 applications are in "/Applications (Mac OS 9)" OS X applications are in "/Applications" localhost:~ vanilla
It is very common in shell scripts to store the name of a command in a variable and then use the variable in a command line later in the script. This is commonly done to allow the same command to be used in many places in the script, but to have only one place where it needs to be changed if you decide to use a different command later.
To use a command inside a variable:
Assign the command name to a variable.
Use the variable (with $ ) anywhere you want to use the command.
Figure 9.7 is a code listing of a script that uses a command in a variable, and Figure 9.8 shows the output of the script.
Figure 9.7. Code listing of a script that uses a command name in a variable.
#!/bin/sh # This script uses a command name in a variable # The du command shows disk usage command="du" # The -s option means "summary". The -k means "in kilobytes" options="-sk" directory="/Developer/ADC Reference Library" # Note the use of quotes around $directory in the command line echo "Trying $command with options $options on '$directory/*'" $command $options "$directory"/*
Figure 9.8. Output from the script in Figure 9.7.
localhost:~ vanilla$ ./diskuse.sh Trying du with options -sk on '/Developer/ADC Reference Library/*' 672 /Developer/ADC Reference Library/docSet.xml 552852 /Developer/ADC Reference Library/documentation 4 /Developer/ADC Reference Library/index.html 67944 /Developer/ADC Reference Library/indexes 107800 /Developer/ADC Reference Library/referencelibrary 10780 /Developer/ADC Reference Library/releasenotes 23936 /Developer/ADC Reference Library/samplecode 11452 /Developer/ADC Reference Library/technicalnotes 28832 /Developer/ADC Reference Library/technicalqas localhost:~ vanilla
Use variables in scripts whenever you want the same thing to appear in more than one place. This minimizes the number of places where you need to make changes.
Try creating the script in Figure 9.7 and changing the command to ls and options to different options for the ls commandfor example, -ld and/or -F .
In previous chapters ( especially Chapter 7), you learned about a special kind of variable called an environment variable . When you execute a script, you are creating a child process of your shell, and so the script's processes inherit your shell's environment. As a result, you can use all of your shell's environment variables in your scripts. Note that assigning anything into an environment variable in a script does not change the contents of that variable for the parent process (your shell), but sets it for any child processes the script creates.
To use an environment variable in a script:
echo "Hello $USER" echo "Your home directory is $HOME"
#!/bin/sh # This script uses environment variables command="du" options="-sk" command_line="$command $options $HOME" echo "User is: $USER" echo "Home directory is: $HOME" echo "Command line will be: $command_line" echo "Disk space usage in kilobytes:" sudo $command_line
localhost:~ vanilla$ ./envscript.sh User is: vanilla Home directory is: /Users/vanilla Command line will be: du -sk /Users/vanilla Disk space usage in kilobytes: Password: 2160 /Users/vanilla localhost:~ vanilla