A shell variable is a memory storage area that can be used to hold a value, which can then be used by any built-in shell command within a single shell. An environment variable is a shell variable that has been exported or published to the environment by a shell command so that shells and shell scripts executed below the parent shell also have access to the variable.

One built-in shell command can set a shell variable value, while another can pick it up. In the following doecho script example, $PLACE is set in the first line and picked up in the second line by the built-in echo command.

Create this script and save it as doecho. Change the mode using chmod a+x doecho:

# doecho sample variable
PLACE=Hollywood
echo "doecho says Hello " $PLACE

Run the program as shown below.

In all of the following examples, I use the convention of ./command to execute a shell script in the current directory. You don't need to do this if your $PATH variable contains the . as one of the searched directories. The ./command method works for scripts in your current directory, even if the current directory isn't included on your path.

$ ./doecho
doecho says Hello Hollywood
$

In this first example, $PLACE is a shell variable.

Now, create another shell script called echoplace and change its mode to executable.

# echoplace echo $PLACE variable
echo "echoplace says Hello " $PLACE

Modify doecho to execute echoplace as its last step.

# doecho sample variable
PLACE=Hollywood
echo "doecho says Hello " $PLACE
./echoplace

Run the doecho script. The output is a bit surprising.

$ ./doecho
doecho says Hello Hollywood
echoplace says Hello
$

In this example, echoplace is run as the last command of doecho. It tries to echo the $PLACE variable but comes up blank. Say goodbye to Hollywood.

To understand what happened here you need understand something about shell invocation -- the sequence of events that occur when you run a shell or shell script. When a shell begins to execute any command, it checks to see if the command is built-in (like echo), an executable program (like vi or grep), a user-defined function, or an executable shell script. If it's any of the first three, it directly executes the command, function, or program; but if the command is an executable shell script, the shell spawns another running copy of itself -- a child shell. The spawned child shell uses the shell script as an input file and reads it in line by line as commands to execute.

When you type ./doecho to execute the doecho script, you're actually executing a command that is something like one of the following, depending on which shell you're using.

$ sh < ./doecho
            (or)
$ ksh <./doecho

The new shell, spawned as a child of your starting-level shell, opens doecho and begins reading commands from that file. It performs the same test on each

• Email
• Print
• Share
  • Slashdot
  • Digg
  • Stumble
  • Reddit
  • Newsvine