Previous Section  < Day Day Up >  Next Section

11.9. Variables

11.9.1 Local Variables

Local variables are given values that are known only to the shell in which they are created. Variable names must begin with an alphabetic or underscore character. The remaining characters can be alphabetic, decimal digits zero to nine, or an underscore character. Any other characters mark the termination of the variable name.

Setting and Referencing Local Variables

When assigning a value to a variable, there can be no whitespace surrounding the equal sign. To set the variable to null, the equal sign is followed by nothing. If more than one word is assigned to a variable, it must be quoted to protect the whitespace; otherwise, the shell prints an error message and the variable is undefined.

If a dollar sign is prepended to the variable name, the value assigned to that variable can be referenced. If other characters are attached to a variable name, curly braces are used to shield the name of the variable from the extra characters.

Example 11.34.

1   $ state=Cal

    $ echo $state

    Cal

2   $ name="Peter Piper"

    $ echo $name

    Peter Piper

3   $ x=

    $ echo $x

                    # Blank line appears when a variable is either unset or set to null

    $

4   $ state=Cal

    $ print ${state}ifornia

    California


EXPLANATION

  1. The variable state is assigned the value Cal. When the shell encounters the dollar sign preceding a variable name, it performs variable substitution. The value of the variable is displayed.

  2. The variable name is assigned the value "Peter Piper". The quotes are needed to hide the whitespace so that the shell will not split the string into separate words when it parses the command line. The value of the variable is displayed.

  3. The variable x is not assigned a value. It will be assigned a null string. The null value, an empty string, is displayed. The same output would be displayed if the variable had not been set at all.

  4. The variable state is assigned the value Cal. The variable is enclosed in curly braces to shield it from the characters that are appended. The value of the variable Cal is displayed with ifornia appended.

The Scope of Local Variables

A local variable is known only to the shell in which it was created. It is not passed on to subshells. The $$ variable is a special variable containing the PID of the current shell.

Example 11.35.

1   $ echo $$

    1313

2   $ round=world

    $ echo $round

    world

3   $ ksh     # Start a subshell

4   $ echo $$

    1326

5   $ echo $round

6   $ exit       # Exits this shell, returns to parent shell

7   $ echo $$

    1313

8   $ echo $round

    world


EXPLANATION

  1. The value of the $$ variable evaluates to the PID of the current shell. The PID of this shell is 1313.

  2. The local variable round is assigned the string value world and the value of the variable is displayed.

  3. A new Korn shell is invoked. This is called a subshell, or child shell.

  4. The PID of this shell is 1326. The parent shell's PID is 1313.

  5. The variable round is not defined in this shell.

  6. The exit command terminates this shell and returns to the parent shell. If the ignoreeof option is not set, Ctrl-D will also exit this shell.

  7. The parent shell returns. Its PID is displayed.

  8. The value of the variable is displayed.

Setting Read-Only Variables

A read-only variable cannot be redefined or unset. It can be set with the readonly or typeset –r built-in commands. You may want to set variables to readonly for security reasons when running in privileged mode.

Example 11.36.

1   $ readonly name=Tom

    $ print $name

    Tom

2   $ unset name

    ksh: name: is read only

3   $ name=Joe

    ksh name: is read only

4   $ typeset -r PATH

    $ PATH=${PATH}:/usr/local/bin

    ksh: PATH: is read only


EXPLANATION

  1. The readonly local variable name is assigned the value Tom.

  2. A readonly variable cannot be unset.

  3. A readonly variable cannot be redefined.

  4. The PATH variable is set to be readonly. Any effort to unset or change the variable will produce an error message.

11.9.2 Environment Variables

Environment variables are available to the shell in which they are created and any subshells or processes spawned from that shell. By convention, environment variables are capitalized.

The shell in which a variable is created is called the parent shell. If a new shell is started from the parent shell, it is called the child shell. Some of the environment variables, such as HOME, LOGNAME, PATH, and SHELL, are set before you log in by the /bin/login program. Normally, environment variables are set in the .profile file in the user's home directory.

Setting Environment Variables

To set environment variables, the export command is used either after assigning a value or when the variable is set. All variables in a script can be exported by turning on the allexport option to the set command (e.g., set -o allexport).

Example 11.37.

1   $ TERM=wyse ; export TERM

2   $ export NAME ="John Smith"

    $ print $NAME

    John Smith

3   $ print $$

    319

4   $ ksh

5   $ print $$

    340

6   $ print $NAME

    John Smith

7   $ NAME="April Jenner"

    $ print $NAME

    April Jenner

8   $ exit

9   $ print $$

    319

10  $ print $NAME

    John Smith


EXPLANATION

  1. The TERM variable is assigned wyse. The variable is exported. Now processes started from this shell will inherit the variable.

  2. The variable is exported and defined in the same step. (New with the Korn shell.)

  3. The value of this shell's PID is printed.

  4. A new Korn shell is started. The new shell is the child; the original shell is its parent.

  5. The PID of the new Korn shell, stored in the $$ (340) variable, is printed.

  6. The variable was exported to the new shell and is displayed.

  7. The variable is reset to April Jenner and displayed.

  8. This Korn child shell is exited. The parent shell will return.

  9. The PID of the parent, 319, is displayed again.

  10. The variable NAME contains its original value. Variables retain their values when exported from parent to child. The child cannot change the value of a variable for its parent.

Special Environment Variables

The Korn shell assigns default values to the environment variables, PATH, PS1, PS2, PS3, PS4, MAILCHECK, FCEDIT, TMOUT, and IFS. The SHELL, LOGNAME, USER, and HOME are set by the /bin/login program. You can change the values of the defaults and set the others listed in Table 11.9.

Table 11.9. Korn Shell Environment Variables

Variable Name

Meaning

_ (underscore)

The last argument of the previous command.

CDPATH

The search path for the cd command. A colon-separated list of directories used to find a directory if the /, ./, or ../ is not at the beginning of the pathname.

COLUMNS

If set, defines the width of the edit window for shell edit modes and the select command.

EDITOR

Pathname for a built-in editor: emacs, gmacs, or vi.

ENV

A variable set to the name of a file, containing functions and aliases, that the Korn shell will invoke when the ksh program is invoked. On versions newer than 1988, this file is only executed when ksh is invoked interactively, not for noninteractive shells. The variable is not expanded if the privileged option is turned on.

ERRNO

System error number. Its value is the error number of the most recently failed system call.

FCEDIT

Default editor name for the fc command. On versions newer than 1988, this variable is called HISTEDIT, and the fc command is hist.

FPATH

A colon-separated list of directories that defines the search path for directories containing auto-loaded functions.

HISTEDIT

For versions of the Korn shell newer than 1988, the new name for FCEDIT.

HISTFILE

Specifies file in which to store command history.

HISTSIZE

Maximum number of commands from the history that can be accessed; default is 128.

HOME

Home directory; used by cd when no directory is specified.

IFS

Internal field separators, normally space, tab, and newline, used for field splitting of words resulting from command substitution, lists in loop constructs, and reading input.

LINENO

Current line number in script.

LINES

Used in select loops for vertically displaying menu items; default is 24.

MAIL

If this parameter is set to the name of a mail file and the MAILPATH parameter is not set, the shell informs the user of the arrival of mail in the specified file.

MAILCHECK

This parameter specifies how often (in seconds) the shell will check for the arrival of mail in the files specified by the MAILPATH or MAIL parameters. The default value is 600 seconds (10 minutes). If set to zero, the shell will check before issuing each primary prompt.

MAILPATH

A colon-separated list of filenames. If this parameter is set, the shell informs the user of the arrival of mail in any of the specified files. Each filename can be followed by a % and a message that will be printed when the modification time changes. The default message is You have mail.

OLDPWD

Last working directory.

PATH

The search path for commands; a colon-separated list of directories the shell uses to search for the command you want to execute.

PWD

Present working directory; set by cd.

PPID

Process ID of the parent process.

PS1

Primary prompt string, by default $.

PS2

Secondary prompt string, by default >.

PS3

Selection prompt string used with the select command, by default #?.

PS4

Debug prompt string used when tracing is turned on, by default +.

RANDOM

Random number generated each time the variable is referenced.

REPLY

Set when read is not supplied arguments.

SHELL

When the shell is invoked, it scans the environment for this name. The shell gives default values to PATH, PS1, PS2, MAILCHECK, and IFS. HOME and MAIL are set by login.

TMOUT

Specifies number of seconds to wait for input before exiting.

VISUAL

Specifies editor for in-line command editing: emacs, gmacs, or vi.


11.9.3 Listing Set Variables

There are three built-in commands that print the value of variables: set, env, and typeset. The set command prints all variables, local and global. The env command prints only global variables. The typeset command prints all variables, integers, functions, and exported variables. The set –o command prints all options set for the Korn shell.

Example 11.38.

1   $ env       # Partial list

    LOGNAME=ellie

    TERMCAP=sun–cmd:te=\E[>4h:ti=\E[>4l:tc=sun:

    USER=ellie

    DISPLAY=:0.0

    SHELL=/bin/ksh

    HOME=/home/jody/ellie

    TERM=sun–cmd

    LD_LIBRARY_PATH=/usr/local/OW3/lib

    PWD=/home/jody/ellie/perl



2   $ typeset

    export MANPATH

    export PATH

    integer ERRNO

    export FONTPATH

    integer OPTIND

    function LINENO

    export OPENWINHOME

    export LOGNAME

    function SECONDS

    integer PPID

    PS3

    PS2

    export TERMCAP

    OPTARG

    export USER

    export DISPLAY

    function RANDOM

    export SHELL

    integer TMOUT

    integer MAILCHECK



3   $ set

    DISPLAY=:0.0

    ERRNO=10

    FCEDIT=/bin/ed

    FMHOME=/usr/local/Frame–2.1X

    FONTPATH=/usr/local/OW3/lib/fonts

    HELPPATH=/usr/local/OW3/lib/locale:/usr/local/OW3/lib/help

    HOME=/home/jody/ellie

    IFS=

    LD_LIBRARY_PATH=/usr/local/OW3/lib

    LINENO=1

    LOGNAME=ellie

    MAILCHECK=600

    MANPATH=/usr/local/OW3/share/man:/usr/local/OW3/man:/

    usr/local/man:/usr/local/doctools/man:/usr/man

    OPTIND=1

    PATH=/home/jody/ellie:/usr/local/OW3/bin:/usr/ucb:/

    usr/local/doctools/bin:/usr/bin:/usr/local:/usr/etc:/etc:/

    usr/spool/news/bin:/home/jody/ellie/bin:/usr/lo

    PID=1332

    PS1=$

    PS2=>

    PS3=#?

    PS4=+

    PWD=/home/jody/ellie/kshprog/joke

    RANDOM=4251

    SECONDS=36

    SHELL=/bin/ksh

    TERM=sun–cmd

    TERMCAP=sun–cmd:te=\E[>4h:ti=\E[>4l:tc=sun:

         TMOUT=0

    USER=ellie

    _=pwd

    name=Joe

    place=San Francisco

    x=



4   set -o

    allexport      off

    bgnice        on

    emacs         off

    errexit       off

    gmacs         off

    ignoreeof     off

    interactive   on

    keyword       off

    markdirs      off

    monitor       on

    noexec        off

    noclobber     off

    noglob        off

    nolog         off

    nounset       off

    privileged    off

    restricted    off

    trackall      off

    verbose       off

    viraw         off

    xtrace        off


EXPLANATION

  1. The env command lists all environment (exported) variables. These variables are, by convention, named with uppercase letters. They are passed from the process in which they are created to any of the child processes.

  2. The typeset command displays all variables and their attributes, functions, and integers. The typeset command with the + option displays only the names of the variables.

  3. The set command, without options, prints all set variables, local and exported, including variables set to null.

  4. The set command with the –o option lists all built-in variables that are set to on or off. To turn options off, use the plus sign (+), and to turn options on, use the minus sign (); for example, set –o allexport turns on the allexport option, causing all variables to be set as global.

11.9.4 Unsetting Variables

Both local and environment variables can be unset by using the unset command (unless the variables are set to readonly).

Example 11.39.

unset name; unset TERM


EXPLANATION

The variables name and TERM are no longer defined for this shell.

11.9.5 Printing the Values of Variables

The echo command (used in Bourne and C shells) is still effective in this shell, but the print command has more options and is more efficient. Both the echo command and print command are built into the shell. The print command has a number of options to control its output. They are listed in Table 11.10.

Table 11.10. print Options

Option

Meaning

Any arguments that follow are not print options. The dash allows arguments that contain a hyphen, for example, –2.

–f

For versions newer than 1988, used to emulate printf.

–n

No newline in output; like echo –n.

–p

Sends output to a coprocess or pipe (&|) rather than to standard output.

–r

Prevents the print command from interpreting escape sequences.

–R

Prevents ksh from treating a –2 or –x as a print argument; turns off the dash if preceding an argument (except –n); \t, \c, \c are not recognized as special and appear unchanged when printed without the \.

–s

Output is appended to the history file as a command rather than to standard output.

–un

Redirects output to file descriptor n.


Example 11.40.

1   $ print Hello my friend and neighbor!

    Hello my friend and neighbor!

2   $ print "Hello       friends"

    Hello       friends



3   $ print –r "\n"

    \n

4   $ print -s "date +%H"

    $ history -2

    132 print -s "date +%H"

    133 date +%H

    134 history -2

    $ r 133

    09

5   $ print –n $HOME

    /home/jody/ellie

6   $ var=world

    $ print ${var}wide

    worldwide

7   $ print –x is an option

    ksh: print: bad option(s)

8   $ print  – –x is an option

    –x is an option


EXPLANATION

  1. The shell parses the command line, breaks the command line into words (tokens) separated by space, and passes the words as arguments to the print command. The shell removes all the extra whitespace between words.

  2. The quotes create a single string. The shell evaluates the string as a single word and the whitespace is preserved.

  3. This is the raw option. Any escape sequences, such as \r, are not interpreted.

  4. The –s option appends the print command's arguments to the history file as a command. The string "date +%H" is the argument to the print command. The date string is appended to the history list as a command and then executed with the r command (history's redo command).

  5. The –n option suppresses the newline. The Korn shell prompt is on the same line as the output from the print command.

  6. The local variable is assigned the value world. The braces insulate the variable from characters appended to it.

  7. When the first argument to the print function begins with a dash, the print command interprets the argument as one of its options, unless an additional preceding dash is provided.

  8. The dash as an option allows you to use a dash as the first character in the string to be printed.

11.9.6 Escape Sequences

Escape sequences consist of a character preceded by a backslash and have a special meaning when enclosed within quotes. (See Table 11.11.)

Table 11.11. Escape Sequences

Backslash Character

Meaning

\a

Bell character

\b

Backspace

\c

Suppress newline and ignore any arguments that follow \c

\f

Formfeed

\n

Newline

\r

Return

\t

Tab

\v

Vertical tab

\\

Backslash

\0x

Eight-bit character with a 1-, 2-, or 3-digit ASCII value, as in print \0124

\E

Only on versions newer than 1988; used for an escape sequence


The print command, without the –r and –R options, formats output when any of the following escape sequences are placed within a string. The string must be enclosed in double or single quotes.

Example 11.41.

1   $ print '\t\t\tHello\n'

                  Hello



    $



2   $ print "\aTea \tTime!\n\n"

    Ding ( bell rings ) Tea       Time!


EXPLANATION

  1. The backslash characters must be quoted with either single or double quotes. The \t escape sequence represents a tab, and \n represents a newline. The output is three tabs, followed by the string Hello, and a newline.

  2. The \a escape sequence causes a bell to ring (\07) and the \t creates a tab. The two \n sequences will print two newline characters.

11.9.7 Variable Expressions and Expansion Modifiers

Variable expressions can be tested and modified by using special modifiers. The modifier provides a shortcut conditional test to check whether a variable has been set, and then, depending on the modifier, may assign a default value to the variable. These expressions can be used with conditional constructs such as if and elif. See Table 11.12.

Table 11.12. Variable Expressions and Modifiers

Expression

Function

${variable:–word}

If variable is set and is nonnull, substitute its value; otherwise, substitute word.

${variable:=word}

If variable is not set or is null, set it to word; the value of variable is substituted permanently. Positional parameters may not be assigned in this way.

${variable:+word}

If variable is set and is nonnull, substitute word; otherwise substitute nothing.

${variable:?word}

If variable is set and is nonnull, substitute its value; otherwise, print word and exit from the shell. If word is omitted, the message parameter null or not set is printed.


The colon does not have to be used with the modifier. Using the colon with the modifier checks whether the variable is not set or is null; without the colon, a variable set to null is considered a set variable.

Example 11.42.

(Using Temporary Default Values)

1   $ fruit=peach

2   $ print ${fruit:–plum}

    peach

3   $ print ${newfruit:–apple}

    apple

4   $ print $newfruit



5   $ print ${TERM:-vt120}

    sun-cmd


EXPLANATION

  1. The variable fruit is assigned the value peach.

  2. The special modifier will check to see if the variable fruit has been set. If it has, the value peach is printed; if not, plum is printed.

  3. The variable newfruit has not been set. The value apple will be printed.

  4. The variable newfruit was not set, so nothing prints. In step 3, the expression was simply replaced with the word apple and printed.

  5. If the TERM variable has not been set, a default value vt120 will be displayed. In this example, the terminal has already been set to sun–cmd, a Sun workstation.

Example 11.43.

(Assigning Permanent Default Values)

1   $ name=

2   $ print ${name:=Patty}

    Patty

3   $ print $name

    Patty

4   $ print ${TERM:=vt120}

    vt120

    $ print $TERM

    vt120


EXPLANATION

  1. The variable name is assigned the value null.

  2. The special modifier := will check to see if the variable name has been set to some value other than null. If it has been set, it will not be changed; if it is either null or not set, it will be assigned the value to the right of the equal sign. Patty is assigned to name because the variable is set to null. The setting is permanent.

  3. The variable name still contains the value Patty.

  4. If the variable TERM is not set, it will be assigned the default value vt120 permanently.

Example 11.44.

(Assigning Temporary Alternate Value)

1   $ foo=grapes

2   $ print ${foo:+pears}

    pears

    $ print $foo

    grapes


EXPLANATION

  1. The variable foo has been assigned the value grapes.

  2. The special modifier :+ will check to see if the variable has been set. If it has been set, it will temporarily be reset to grapes. If it has not been set, null is returned.

Example 11.45.

(Creating Error Messages Based on Default Values)

1   $ print ${namex:?"namex is undefined"}

    ksh: namex: namex is undefined

2   $ print ${y?}

    ksh: y: parameter null or not set


EXPLANATION

  1. The :? modifier will check to see if the variable has been set. If not, the string to the right of the ? is printed to standard error, after the name of the variable. If in a script, the script exits.

  2. If a message is not provided after the ?, the Korn shell sends a default message to standard error. Without the colon, the ? modifier would consider a variable set to null a set variable, and the message would not be printed.

Example 11.46.

(Line from a System Script)

if [ "${uid:=0}" -ne 0 ]


EXPLANATION

If the UID (user ID) has a value, it will not be changed; if it does not have a value, it will be assigned the value zero (superuser). The value of the variable will be tested for nonzero. This line was taken from the /etc/shutdown program (SVR4/Solaris 2.5). It is here to give you an example of how variable modifiers are used.

11.9.8 Variable Expansion of Substrings

Pattern-matching arguments are used to strip off certain portions of a string from either the front or end of the string. The most common use for these operators is stripping off pathname elements from the head or tail of the path. See Table 11.13.

Table 11.13. Variable Expansion Substrings

Expression

Function

${variable%pattern}

Matches the smallest trailing portion of the value of variable to pattern and removes it.

${variable%%pattern}

Matches the largest trailing portion of the value of variable to pattern and removes it.

${variable#pattern}

Matches the smallest leading portion of the value of variable to pattern and removes it.

${variable##pattern}

Matches the largest leading portion of the value of variable to pattern and removes it.


Example 11.47.

1   $ pathname="/usr/bin/local/bin"

2   $ print ${pathname%/bin*}

    /usr/bin/local


EXPLANATION

  1. The local variable pathname is assigned /usr/bin/local/bin.

  2. The % removes the smallest trailing portion of pathname containing the pattern /bin, followed by zero or more characters; that is, it strips off /bin.

Example 11.48.

1   $ pathname="usr/bin/local/bin"

2   $ print ${pathname%%/bin*}

    /usr


EXPLANATION

  1. The local variable pathname is assigned /usr/bin/local/bin.

  2. The %% removes the largest trailing portion of pathname containing the pattern /bin, followed by zero or more characters; that is, it strips off /bin/local/bin.

Example 11.49.

1   $ pathname=/home/lilliput/jake/.cshrc

2   $ print ${pathname#/home}

    /lilliput/jake/.cshrc


EXPLANATION

  1. The local variable pathname is assigned /home/liliput/jake/.cshrc.

  2. The # removes the smallest leading portion of pathname containing the pattern /home; that is, /home is stripped from the beginning of the path variable.

Example 11.50.

1   $ pathname=/home/liliput/jake/.cshrc

2   $ print ${pathname##*/}

    .cshrc


EXPLANATION

  1. The local variable pathname is assigned /home/liliput/jake/.cshrc.

  2. The ## removes the largest leading portion of pathname containing zero or more characters up to and including the last slash; that is, it strips off /home/lilliput/jake/ from the path variable.

11.9.9 Variable Attributes: The typeset Command

The attributes of a variable, such as its case, width, and left or right justification, can be controlled by the typeset command. When the typeset command changes the attributes of a variable, the change is permanent. The typeset function has a number of other functions. See Table 11.14.

Example 11.51.

1   $ typeset –u name="john doe"

    $ print "$name"

    JOHN DOE             # Changes all characters to uppercase.



2   $ typeset –l name

    $ print $name

    john doe             # Changes all characters to lowercase.



3   $ typeset –L4 name

    $ print $name

    john                 # Left-justified fixed-width 4-character field.





4   $ typeset –R2 name

    $ print $name                # Right-justified fixed-width 2-character field.

    hn



5   $ name="John Doe"

    $ typeset –Z15 name         # Null–padded sting, 15-space field width

    $ print "$name"

     John Doe



6   $ typeset –LZ15 name        # Left-justified, 15-space field width.

    $ print "$name$name"

    John Doe       John Doe



7   $ integer n=25

    $ typeset -Z15 n            # Left-justified, zero-padded integer.

    $ print "$n"

    000000000000025



8   $ typeset –lL1 answer=Yes   # Left justify one lowercase letter.

    $ print $answer

    y


Table 11.14. Other Uses of the typeset Command

Command

What It Does

typeset

Displays all variables

typeset –i num

Will only accept integer values for num

typeset –x

Displays exported variables

typeset a b c

If defined in a function, creates a, b, and c to be local variables

typeset –r x=foo

Sets x to foo and then makes it read-only


EXPLANATION

  1. The –u option to the typeset command converts all characters in a variable to uppercase.

  2. The –l option to the typeset command converts all characters in a variable to lowercase.

  3. The –L option to the typeset command converts the variable name to a left-justified, four-character string, john.

  4. The –R option to the typeset command converts the variable name to a right-justified, two-character string, hn.

  5. The variable name is set to John Doe. The –Z option to the typeset command will convert the string to a null-padded, 15-space string. The variable is quoted to preserve whitespace.

  6. The variable name is converted to a left-justified, 15-space, null-padded string.

  7. The variable n is an integer (see typeset –i, Table 11.14) assigned the value 25. The typeset command will convert the integer n to a zero-filled, 15-space, left-justified number.

  8. The variable answer is assigned the value Yes and converted to a lowercase, left-justified, one-character string. (This can be very useful when handling user input in a script.)

11.9.10 Positional Parameters

Normally, the special built-in variables, often called positional parameters, are used in shell scripts when passing arguments from the command line, or used in functions to hold the value of arguments passed to the function. The variables are called positional parameters because they are referenced by numbers 1, 2, 3, and so on, representing their respective positions in the parameter list. See Table 11.15.

Table 11.15. Positional Parameters

Expression

Function

$0

References the name of the current shell script

$1–$9

Positional parameters 1–9

${10}

Positional parameter 10

$#

Evaluates to the number of positional parameters

$*

Evaluates to all the positional parameters

$@

Same as $*, except when double quoted

"$*"

Evaluates to "$1 $2 $3", and so on

"$@"

Evaluates to "$1" "$2" "$3", and so on


The name of the shell script is stored in the $0 variable. The positional parameters can be set and reset with the set command.

Example 11.52.

1   $ set tim bill ann fred

    $ print $*           # Prints all the positional parameters.

    tim bill ann fred



2   $ print $1           # Prints the first position.

    tim



3   $ print $2 $3        # Prints the second and third position.

    bill ann



4   $ print $#           # Prints the total number of positional parameters.

    4



5   $ set a b c d e f g h i j k l m

    $ print $10          # Prints the first positional parameter followed by a 0.

    a0



    $ print ${10} ${11}  # Prints the 10th and 11th positions.

    j k



6   $ print $#

    13



7   $ print $*

    a b c d e f g h i j k l m



8   $ set file1 file2 file3

    $ print \$$#

    $3



9   $ eval print \$$#

    file3


EXPLANATION

  1. The set command assigns values to positional parameters. The $* special variable contains all of the parameters set.

  2. The value of the first positional parameter, tim, is displayed.

  3. The value of the second and third parameters, bill and ann, are displayed.

  4. The $# special variable contains the number of positional parameters currently set.

  5. The set command resets all of the positional parameters. The original parameter list is cleared. To print any positional parameters beyond 9, the curly braces are used to keep the two digits together. Otherwise, the value of the first positional parameter is printed, followed by the number appended to it.

  6. The number of positional parameters is now 13.

  7. The values of all the positional parameters are printed.

  8. The dollar sign is escaped; $# is the number of arguments. The print command displays $3, a literal dollar sign followed by the number of positional parameters.

  9. The eval command parses the command line a second time before executing the command. The first time parsed by the shell, the print would display $3; the second time, after eval, the print displays the value of $3, file3.

11.9.11 Other Special Variables

The Korn shell has some special built-in variables, as shown in Table 11.16.

Table 11.16. Special Variables

Variable

Meaning

$$

PID of the shell

$–

ksh options currently set

$?

Exit value of last executed command

$!

PID of last job put in background


Example 11.53.

1   $ print The pid of this shell is $$

    The pid of this shell is 4725

2   $ print The options for this korn shell are $–

    The options for this korn shell are ismh

3   $ grep dodo /etc/passwd

    $ print $?

    1

4   $ sleep 25&

    [1]    400

    $ print $!

    400


EXPLANATION

  1. The $$ variable holds the value of the PID for this process.

  2. The $– variable lists all options for this interactive Korn shell.

  3. The grep command searches for the string dodo in the /etc/passwd file. The ? variable holds the exit status of the last command executed. Because the value returned from grep is 1, grep is assumed to have failed in its search. An exit status of 0 indicates a successful exit.

  4. The & appended to the sleep command causes the command to be executed in the background. The $! variable holds the PID of the last command placed in the background.

    Previous Section  < Day Day Up >  Next Section