Variable and File Name Substitution in the Bourne Shell

The Bourne shell permits you to do variable and file name substitutions.

The following sections offer information about creating and substituting variables in the Bourne shell:

• Variable Substitution in the Bourne Shell
• User-Defined Variables
• Conditional Substitution
• Positional Parameters
• File Name Substitution in the Bourne Shell
• Character Classes
• Related Information

Variable Substitution in the Bourne Shell

The Bourne shell has several mechanisms for creating variables (assigning a string value to a name). Certain variables, positional parameters and keyword parameters, are normally set only on a command line. Other variables are simply names to which you or the shell can assign string values.

User-Defined Variables

The shell recognizes alphanumeric variables to which string values can be assigned. To assign a string value to a name, enter:

Name=String

A name is a sequence of letters, digits, and underscores that begins with an underscore or a letter. To use the value that you have assigned to a variable, add a $ (dollar sign) to the beginning of its name. Thus, the $Name variable yields the value specified by the String variable. Note that no spaces are on either side of the = (equal sign) in an assignment statement. (Positional parameters cannot appear in an assignment statement. They can only be set as described in Positional Parameters .) You can put more than one assignment on a command line, but remember that the shell performs the assignments from right to left.

If you enclose the String variable with " or ' (double or single quotation marks), the shell does not treat blanks, tabs, semicolons, and new-line characters within the string as word delimiters, but imbeds them literally in the string.

If you enclose the String variable with " (double quotation marks), the shell still recognizes variable names in the string and performs variable substitution; that is, it replaces references to positional parameters and other variable names that are prefaced by $ (dollar sign) with their corresponding values, if any. The shell also performs command substitution within strings that are enclosed in double quotation marks.

If you enclose the String variable with ' (single quotation marks), the shell does not substitute variables or commands within the string. The following sequence illustrates this difference:

You:            num=875
                number1="Add $num"
                number2='Add $num'
                echo $number1
System:         Add 875
You:            echo $number2
System:         Add $num

The shell does not reinterpret blanks in assignments after variable substitution. Thus, the following assignments result in $first and $second having the same value:

first='a string with embedded blanks'
second=$first

When you reference a variable, you can enclose the variable name (or the digit designating a positional parameter) in { } (braces) to delimit the variable name from any string following. In particular, if the character immediately following the name is a letter, digit, or underscore, and the variable is not a positional parameter, then the braces are required:

You:            a='This is a'
                echo "${a}n example"
System:         This is an example
You:            echo "$a test"
System:         This is a test

Refer to Conditional Substitution for a different use of braces in variable substitutions.

Variables Used by the Shell

The shell uses the following variables. While the shell sets some of them, you can set or reset all of them:

PATH=/project/bin:$PATH

Predefined Special Variables

Several variables have special meanings. The following variables are set only by the shell.

temp=/tmp/$$
ls >$temp
.
.
.
rm $temp

Blank Interpretation

After the shell performs variable and command substitution, it scans the results for internal field separators (those defined in the IFS shell variable). The shell splits the line into distinct words at each place it finds one or more of these characters separating each distinct word with a single space. It then retains explicit null arguments ("" or '') and discards implicit null arguments (those resulting from parameters that have no values).

Conditional Substitution

Normally, the shell replaces the expression $Variable with the string value assigned to the Variable variable, if there is one. However, there is a special notation that allows conditional substitution, depending on whether the variable is set or not null, or both. By definition, a variable is set if it has ever been assigned a value. The value of a variable can be the null string, which you can assign to a variable in any one of the following ways:

A=

bcd=""

The following is a list of the available expressions you can use to perform conditional substitution:

Variable: String

Variable: parameter null or not set

Variable: String

Variable: parameter null or not set

In conditional substitution, the shell does not evaluate the String variable until the shell uses this variable as a substituted string. Thus, in the following example, the shell executes the pwd command only if d is not set or is null:

echo ${d:-`pwd`}

Positional Parameters

When you run a shell procedure, the shell implicitly creates positional parameters that reference each word on the command line by its position on the command line. The word in position 0 (the procedure name) is called $0, the next word (the first parameter) is called $1, and so on, up to $9. To refer to command line parameters numbered higher than 9, use the built-in shift command.

You can reset the values of the positional parameters explicitly by using the built-in set command.

Note: When an argument for a position is not specified, its positional parameter is set to null. Positional parameters are global and can be passed to nested shell procedures.

File Name Substitution in the Bourne Shell

Command parameters are often file names. You can automatically produce a list of file names as parameters on a command line. To do this, specify a character that the shell recognizes as a pattern-matching character. When a command includes such a character, the shell replaces it with the file names in a directory.

Note: The Bourne shell does not support file name expansion based on equivalence classification of characters.

Most characters in such a pattern match themselves, but you can also use some special pattern-matching characters in your pattern. These special characters are:

Within square brackets, a pair of characters separated by a - (hyphen) specifies the set of all characters lexically within the inclusive range of that pair, according to the binary ordering of character values.

Pattern matching has some restrictions. If the first character of a file name is a . (dot), it can be matched only by a pattern that also begins with a dot. For example, * (asterisk) matches the file names myfile and yourfile but not the file names .myfile and .yourfile . To match these files, use a pattern such as the following:

.*file

If a pattern does not match any file names, then the pattern itself is returned as the result of the attempted match.

File and directory names should not contain the characters * (asterisk), ? (question mark), [ (left bracket), or ] (right bracket) because they can cause infinite recursion (that is, infinite loops) during pattern-matching attempts.

Character Classes

You can also use character classes to match file names:

[[:charclass:]]

This format instructs the system to match any single character belonging to the specified class. The defined classes correspond to ctype subroutines. They are: