Learning the Basics of Shell Scripting in Bash

Understanding Bash Variables

You define variables in Bash just as you define environment variables. Thus, you might define a variable as follows:

count=12  # note no embedded spaces allowed

To use a variable's value, prefix the variable's name with a dollar sign ($). $PATH, for example, is the value of the variable PATH (yes, the famous PATH environment variable that contains the list of directories to search for any commands the user types). To display the value of the variable count, use the following command:

echo $count

Bash has some special variables for accessing command-line arguments. In a shell script, $0 refers to the name of the shell script. The variables $1, $2, and so on refer to the command-line arguments. The variable $* stores all the command-line arguments as a single variable, and $? contains the exit status of the last command the shell executes.

In addition, you can prompt the user for input and use the read command to read the input into a variable. Following is an example:

echo -n "Enter value: "
read value
echo "You entered: $value."

Writing Shell Functions

You can group a number of shell commands into a function and assign it a name. Later, you can execute that group of commands by using the single name assigned to the function. Here is a simple script that illustrates the syntax of shell functions:

#!/bin/sh

hello() {
        echo -n "Hello, "
        echo $1 $2
}

hello Jane Doe

When you run this script, it displays the following output:

Hello, Jane Doe

This script defines a shell function named hello. The function expects two arguments; in the body of the function, these arguments are referenced by $1 and $2. The function definition begins with hello()-the name of the function, followed by parentheses. The body of the function is enclosed in curly braces-{...}. In this case, the body uses the echo built-in command (see Table 24-1 for a list of built-in commands).

Using Bash Control Structures

In Bash scripts, the control structures-such as if, case, for, and while-depend on the exit status of a command to decide what to do next. When any command executes, it returns an exit status: a numeric value that indicates whether or not the command has succeeded. By convention, an exit status of zero means the command has succeeded. (Yes, you read it right: zero indicates success.) A nonzero exit status indicates that something has gone wrong with the command.

As an example of using control structures, consider the following script, which makes a backup copy of a file before opening it with the vi text editor:

#!/bin/sh
if cp "$1" "#$1"
then
    vi "$1"
else
    echo "Failed to create backup copy"
fi

This script illustrates the syntax of the if-then-else structure and shows how the exit status of the cp command is used by the if structure to determine the next action. If cp returns zero, the script invokes vi to edit the file; otherwise, the script displays a message and exits. By the way, the script names the backup file whose name is the same as that of the original, except for a number sign (#) added at the beginning of the filename.

Bash includes the test command to enable you to evaluate any expression and to use the expression's value as the exit status of the command. Suppose that you want a script that enables you to edit a file only if it exists. Using test, you might write such a script as follows:

#!/bin/sh
if test -f "$1"
then
    vi "$1"
else
    echo "No such file"
fi

Secret

A shorter form of the test command omits test and places the test command's options in square brackets ([...]). Using this notation, you can write the script that enables you to edit only existing files, as follows:

#!/bin/sh
if [ -f "$1" ]
then
    vi "$1"
else
    echo "No such file"
fi

The left square bracket ([) is in fact a symbolic link to /usr/bin/test. You can confirm this fact by typing ls -l /usr/bin/[.

Another common control structure is the for loop. The following script adds the numbers 1 through 10:

#!/bin/sh
sum=0
for i in 1 2 3 4 5 6 7 8 9 10
do
    sum=`expr $sum + $i'
done
echo "Sum = $sum"

This example also illustrates the use of the expr command to evaluate an expression.

The case statement is used to execute a group of commands based on the value of a variable. For example, consider the following script:

#!/bin/sh
echo -n "What should I do -- (Y)es/(N)o/(C)ontinue? [Y] "
read answer
case $answer in
    y|Y|"")
      echo "YES"
    ;;
    c|C)
      echo "CONTINUE"
    ;;
    n|N)
      echo "NO"
    ;;
    *)
      echo "UNKNOWN"
    ;;
esac

Save this in a file named confirm, and type chmod +x confirm to make it executable. Then, try it out like this:

./confirm
What should I do -- (Y)es/(N)o/(C)ontinue? [Y] c
CONTINUE

The script displays a prompt and reads the input you type. Your input is stored in a variable named answer. Then the case statement executes a block of code based on the value of the answer variable. For example, when I type c, the following block of commands is executed:

    c|C)
      echo "CONTINUE"
    ;;

The echo command causes the script to display CONTINUE.

From this example, you can see that the general syntax of the case command is as follows:

case $variable in
    value1 | value2)
    command1
    command2
    ...other commands...
    ;;

    value3)
    command3
    command4
    ...other commands...
    ;;
esac

Essentially, the case command begins with the word case and ends with esac. Separate blocks of code are enclosed between the values of the variable, followed by a right parenthesis and terminated by a pair of semicolons (;;).