You were introduced to the concept of shell variables in Chapter 11, "Bourne Shell." Everything you learned there remains true for the Korn shell. However, the Korn shell provides some significant extensions to shell variable support. Among these are a greatly expanded set of variables having special meaning to the shell. These variables are often called predefined variables, because the shell provides an initial default value for them when you log in. The Korn shell also supports array variables and enhanced arithmetic on shell variables, both of which are a great boon to shell script writers. Naturally, the syntax of shell variable references is expanded to support these capabilities.

Predefined Variables

Variables having special meaning to the shell fall into two main groups: those which you can set to affect the behavior of the shell, and those which the shell sets for you to provide information.

Variables whose values are set by the shell include the familiar $@, $*, $#, $-, $?, and $$, as well as the new $!. The new variable $! provides the process ID of the last command you invoked. It differs from $$ in that the value of $$—your current process ID—is generally that of the shell itself and doesn't change, whereas the value of $! changes everytime you invoke a command. The values of the other shell variables have the same meaning as they do with the Bourne shell.

The following named variables are set by the Korn shell:

The shell variables set by the Korn shell listed above don't require your attention. If you have a use for one of them, refer to it at your keyboard or in a shell script. You don't need to assign values to them, though. In some cases, you aren't even allowed to assign a value.

Some variables, however, require attention from you. In most cases, the Korn shell assigns a default value to these variables when it starts. You may override this default value in your login profile—a file named .profile in your home directory—or at any later time by using an assignment statement from the keyboard. The values of these variables affect the way the Korn shell works. Proper setup of these variables can enhance your effectiveness and productivity.

Variables used by the Korn shell are

As with the Bourne shell, variable names in the Korn shell begin with a letter or an underscore, and they contain an arbitrary number of letters, underscores, and digits. The variable name is a symbolic representation for the variable's value, which can be changed from time by an assignment statement, by the set, read, or select statements, as a by-product of the execution of shell built-in or other commands, or by the Korn shell itself. There is no arbitrary upper limit to the number of variables you can define and use, but the amount of memory available to the shell sets a practical (usually large) upper limit.

You can explicitly assign a value to a variable name using an assignment in the format name=value. Note that you don't write a dollar sign ($) in front of name when you write the assignment. The dollar sign is appropriate only when referring to the value of the variable.

The value of a variable is a string—that is, a sequence of alphanumeric and special characters—of arbitrary length. The Korn shell provides a number of extensions which enable the value of a variable to be manipulated in arithmetic ways. The variable's value is still stored as a string, however.

A variable retains its value from the time it is set—whether explicitly by you or implicitly by the Korn shell—until the value is changed or the shell exits. Note, however, that the value isn't passed to commands and shell scripts that you invoke unless the variable is marked for exportation. You mark a variable for exporting with the typeset shell built-in command or the export alias. Exported variables become part of the environment of all invoked commands.

Because the values of variables are retained internally in a memory table by the shell, all variables that the shell didn't inherit are automatically lost when the shell exits. For this reason, you cannot assign a value to a shell variable inside a shell script—one invocation of the shell—and expect the value to be retained after the shell script exits; the shell returns to a higher level shell. In other words, you can assign values to variables and export the variables to pass values downward to subshells of your current shell, but you cannot pass values upward to higher-level shells or shell scripts.

This limitation on the use of shell variables isn't normally visible to you at the keyboard. It normally arises in issues relating to shell programming. However, if you invoke the shell directly—by entering the sh, ksh, or csh command—or indirectly—by entering the shell environment from within another UNIX command, such as vi or pg—you should realize that any changes to the shell environment, including variable settings and aliases, will be lost when you return to your original shell level by exiting the subshell.

Referencing Variables

The Korn shell replaces strings that begin with $ and are followed by a reference expression appearing in command lines with the value of the reference expression. Any number of reference expressions may appear in the same command line. Adjacent references, when replaced, don't introduce new word boundaries into the command line. That is, a single word—command name, option, or argument—isn't split into two or more words by replacement even if the replaced value contains blanks, tabs, or other delimiter characters. You can use the eval shell built-in command when you want delimiters in the replacement text to cause further word splitting.

The valid reference expressions for the Korn shell are

name

The expression $name is replaced by the current value of the shell variable named name. If no value for the variable has been defined, the dollar sign and the variable name are replaced with the null string. For example,

$ today="January 13"

$ print Today is:$today.

Today is:January 13.

$ print Today is $tomorrow.

Today is:.

{name}

The expression ${name} is replaced by the current value of the shell variable named name. The braces help to separate the variable reference from surrounding text; they are discarded after substitution. You must use braces to reference a shell parameter greater than $9—for example, ${10} or ${12}—or to reference an array variable. For example,

$ Person1=John

$ Person2=Mike

$ print $Person1 and $Person2

John and Mike

$ print $Person1and$Person2

Person1and: not defined

$ print ${Person1}and$Person2

JohnandMike

{name[n]}

The value of the expression is the value of the nth element of the array variable name; it is null if the nth element isn't set. The first element of an array variable is ${name[0]}.

{name[*]}

The value of the expression is the value of all the elements of the array variable name that are set, separated by blanks. Substitution occurs in the same way as for the special expression $* with regard to embedded blanks and word splitting. For example,

$ set -A planets Mercury Venus Earth Mars

$ planet[9]=Pluto

$ print ${planets[*]}

Mercury Venus Earth Mars Pluto

{name[@]}

The value of the expression is the value of all the elements of the array variable name that are set, separated by blanks. If elements of the array contain strings with embedded blanks and if the expression ${name[@]} is contained inside quotes, the number of words in the substituted expression is equal to the number of non-null array elements. Otherwise, embedded blanks cause word splitting to occur, and the number of substituted words will be greater than the number of non-null array elements. For example,

$ set -A committee "B Jones" "M Hartly" "C Rogers"

$ for word in ${committee[@]}

> do

> print $word

> done

B

Jones

M

Hartly

C

Rogers

$ for word in "${committee[@]}"

> do

> print $word

> done

B Jones

M Hartly

C Rogers

{name:-word}

The expression is replaced by the value of variable name, if the variable has a value and the value is at least one character long. Otherwise, the expression is replaced by word. Note that word should not contain embedded blanks or tabs, although it may contain quoted strings.

Combine : with -, =, ?, or + to treat a variable with a null value—that is, a zero-length string—the same as an unset variable. Without :, the variable is tested only for whether it is set. For example,

$ month=January

$ print This month is ${month:-unknown}

This month is January

$ print This year is ${year:-unknown}

This year is unknown

{name-word}

The expression is replaced by the value of name, if the variable has a value. Otherwise, it is replaced by word. You can use ${name:-word} to ignore a value that is not set or is null. For example,

$unset month

$ month=January

$ print This month is ${month:unknown}

This month is January

$ print This year is ${year:unknown}

This year is unknown

{name=word}

The expression is replaced by the value of name, if the variable has a value. Otherwise, word is assigned as the value of word, and the expression is replaced by word. You can use ${name:=word} to assign word to name if the variable is either not set or is null. For example,

$ print This month is $month.

This month is .

$ print This month is ${month=January}.

This month is January.

$ print This month is $month.

This month is January.

{name?word}

The expression is replaced by the value of name, if the variable has a value. Otherwise, the string word is printed as an error message. An unset variable is recognized as an error and halts processing of the current command line. If the error is recognized inside a shell script, execution of the shell script is terminated. Use ${name:?word} to recognize either an unset or null value as an error. For example,

$ month=January

$ print This month is ${month?unknown}

This month is January

$ print This year is ${year?unknown}

ksh: year: unknown

{name+word}

The expression is replaced by the value of word if the variable name has a value. If the variable is not set, the expression is replaced by the null string. That is, if name has a value, it temporarily treats the value as though it were word. If name doesn't have a value, the expression has no value either. Use ${name:+word} to treat a null value the same as an unset value. For example,

$ month=January

$ print This month is ${month+unknown}

This month is unknown.

$ print This year is ${year+unknown}

This year is .

{name#pattern}

The value of the expression is the value of name with the leftmost occurrence of pattern deleted. The shortest match for pattern is recognized. For pattern, specify a string that contains any character sequence, variable and command substitutions, and wildcard expressions. Only the first occurrence of pattern is deleted. For example,

$ print $PWD

/usr/home/valley

$ print ${PWD#*/}

usr/home/valley

{name##pattern}

The value of the expression is the value of name with the leftmost occurrence of pattern deleted. The longest possible match is recognized and deleted. For example,

$ print $PWD

/usr/home/valley

$ print ${PWD##*/}

valley

{name%pattern}

The value of the expression is the value of name with the shortest rightmost string matching pattern deleted. For example,

$ print $FNAME

s.myfile.c

$ print ${FNAME%.*}

s.myfile

{name%%pattern}

The value of the expression is the value of name with the longest rightmost string matching pattern deleted. For example,

$ print $FNAME

s.myfile.c

$ print ${FNAME%%.*}

s

{#@}

The value of the expression is the integer number of arguments that would be returned by $@.

{#*}

The value of the expression is the integer number of arguments that would be returned by $*. It is the same as $#.

{#name}

The value of the expression is the length of the string value of variable name. For example,

$ print $FNAME

s.myfile.c

$ print ${#FNAME}

10

{#name[*]}

The value of the expression is the number of elements of the array variable name that are set. For example,

$ set -A planets Mercury Venus Earth Mars

$ print ${#planets[*]}

4

{#name[@]}

{#name[@]} is the same as {#name[*]}.

Array Variables

An array variable is a variable with more than one value. Array variables are helpful for managing lists of strings, because you can reference an individual element in the list without resorting to string splitting techniques.

You can assign values to an array one at a time by using the assignment statement. For example,

$ planets[1]=Mercury

$ planets[2]=Venus

$ planets[3]=Earth

$ print ${planets[2]}

Venus

The general syntax name[subscript] is supported by the Korn shell for referring to elements of an array. For subscript, supply an integer number in the range of 0 through 511, or write a variable expression whose value is the desired element number. Element numbers begin at zero. Thus, the first element in an array is ${name[0]}.

You can use the -A option of the set command to set many array elements with one statement. For example, the previous code could be rewritten as

$ set -A planets Mercury Venus Earth

$ print ${planets[2]}

Venus

You can also substitute all the elements of an array by using the special notation ${name[*]} or ${name[@]}. For example,

$ set -A planets Mercury Venus Earth

$ planets[9]=Pluto

$ planets[7]=Uranus

$ print The known planets are: ${planets[*]}

The known planets are: Mercury Venus Earth Uranus Pluto

There are a few points to remember when using array variables:

If you reference the array variable without a subscript, the value of the reference is the first element of the array:

$ print $planets


Mercury

Array variables cannot be exported.

The special expression ${#name[*]} or ${#name[@]} can be used to get the number of non-null elements in an array. For example,

$ print There are ${#planets[*]} planets: ${planets[*]}


There are 5 planets: Mercury Venus Earth Uranus Pluto

You must use the brace-enclosed expression syntax to refer to elements of an array. Without the braces, the Korn shell interprets the expression in the same way the Bourne shell would. For example,

$ print The known planets are $planets[*]


The known planets are Mercury[*]


$ print The second planet from the Sun is $planets[2]


The second planet from the sun is Mercury[2]