Chapter 9. Variables Revisited

Used properly, variables can add power and flexibility to scripts. This requires learning their subtleties and nuances.

9.1. Internal Variables

Builtin variables

variables affecting bash script behavior

$BASH

the path to the Bash binary itself
 bash$ echo $BASH
 /bin/bash

$BASH_ENV

an environmental variable pointing to a Bash startup file to be read when a script is invoked

$BASH_SUBSHELL

a variable indicating the subshell level. This is a new addition to Bash, version 3.

See Example 20-1 for usage.

$BASH_VERSINFO[n]

a 6-element array containing version information about the installed release of Bash. This is similar to $BASH_VERSION, below, but a bit more detailed.

   1 # Bash version info:
   2 
   3 for n in 0 1 2 3 4 5
   4 do
   5   echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}"
   6 done  
   7 
   8 # BASH_VERSINFO[0] = 3                      # Major version no.
   9 # BASH_VERSINFO[1] = 00                     # Minor version no.
  10 # BASH_VERSINFO[2] = 14                     # Patch level.
  11 # BASH_VERSINFO[3] = 1                      # Build version.
  12 # BASH_VERSINFO[4] = release                # Release status.
  13 # BASH_VERSINFO[5] = i386-redhat-linux-gnu  # Architecture
  14                                             # (same as $MACHTYPE).

$BASH_VERSION

the version of Bash installed on the system

 bash$ echo $BASH_VERSION
 3.00.14(1)-release
 	      

 tcsh% echo $BASH_VERSION
 BASH_VERSION: Undefined variable.
 	      

Checking $BASH_VERSION is a good method of determining which shell is running. $SHELL does not necessarily give the correct answer.

$DIRSTACK

the top value in the directory stack (affected by pushd and popd)

This builtin variable corresponds to the dirs command, however dirs shows the entire contents of the directory stack.

$EDITOR

the default editor invoked by a script, usually vi or emacs.

$EUID

"effective" user ID number

Identification number of whatever identity the current user has assumed, perhaps by means of su.

Caution

The $EUID is not necessarily the same as the $UID.

$FUNCNAME

name of the current function

   1 xyz23 ()
   2 {
   3   echo "$FUNCNAME now executing."  # xyz23 now executing.
   4 }
   5 
   6 xyz23
   7 
   8 echo "FUNCNAME = $FUNCNAME"        # FUNCNAME =
   9                                    # Null value outside a function.

$GLOBIGNORE

A list of filename patterns to be excluded from matching in globbing.

$GROUPS

groups current user belongs to

This is a listing (array) of the group id numbers for current user, as recorded in /etc/passwd.

 root# echo $GROUPS
 0
 
 
 root# echo ${GROUPS[1]}
 1
 
 
 root# echo ${GROUPS[5]}
 6
 	      

$HOME

home directory of the user, usually /home/username (see Example 9-15)

$HOSTNAME

The hostname command assigns the system name at bootup in an init script. However, the gethostname() function sets the Bash internal variable $HOSTNAME. See also Example 9-15.

$HOSTTYPE

host type

Like $MACHTYPE, identifies the system hardware.

 bash$ echo $HOSTTYPE
 i686
$IFS

internal field separator

This variable determines how Bash recognizes fields, or word boundaries when it interprets character strings.

$IFS defaults to whitespace (space, tab, and newline), but may be changed, for example, to parse a comma-separated data file. Note that $* uses the first character held in $IFS. See Example 5-1.

 bash$ echo $IFS | cat -vte
 $
 (Show tabs and display "$" at end-of-line.)
 
 
 
 bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"'
 w:x:y:z
 (Read commands from string and assign any arguments to pos params.)
 	      

Caution

$IFS does not handle whitespace the same as it does other characters.


Example 9-1. $IFS and whitespace

   1 #!/bin/bash
   2 # $IFS treats whitespace differently than other characters.
   3 
   4 output_args_one_per_line()
   5 {
   6   for arg
   7   do echo "[$arg]"
   8   done
   9 }
  10 
  11 echo; echo "IFS=\" \""
  12 echo "-------"
  13 
  14 IFS=" "
  15 var=" a  b c   "
  16 output_args_one_per_line $var  # output_args_one_per_line `echo " a  b c   "`
  17 #
  18 # [a]
  19 # [b]
  20 # [c]
  21 
  22 
  23 echo; echo "IFS=:"
  24 echo "-----"
  25 
  26 IFS=:
  27 var=":a::b:c:::"               # Same as above, but substitute ":" for " ".
  28 output_args_one_per_line $var
  29 #
  30 # []
  31 # [a]
  32 # []
  33 # [b]
  34 # [c]
  35 # []
  36 # []
  37 # []
  38 
  39 # The same thing happens with the "FS" field separator in awk.
  40 
  41 # Thank you, Stephane Chazelas.
  42 
  43 echo
  44 
  45 exit 0

(Thanks, S. C., for clarification and examples.)

See also Example 15-37, Example 10-7, and Example 18-14 for instructive examples of using $IFS.

$IGNOREEOF

ignore EOF: how many end-of-files (control-D) the shell will ignore before logging out.

$LC_COLLATE

Often set in the .bashrc or /etc/profile files, this variable controls collation order in filename expansion and pattern matching. If mishandled, LC_COLLATE can cause unexpected results in filename globbing.

Note

As of version 2.05 of Bash, filename globbing no longer distinguishes between lowercase and uppercase letters in a character range between brackets. For example, ls [A-M]* would match both File1.txt and file1.txt. To revert to the customary behavior of bracket matching, set LC_COLLATE to C by an export LC_COLLATE=C in /etc/profile and/or ~/.bashrc.

$LC_CTYPE

This internal variable controls character interpretation in globbing and pattern matching.

$LINENO

This variable is the line number of the shell script in which this variable appears. It has significance only within the script in which it appears, and is chiefly useful for debugging purposes.

   1 # *** BEGIN DEBUG BLOCK ***
   2 last_cmd_arg=$_  # Save it.
   3 
   4 echo "At line number $LINENO, variable \"v1\" = $v1"
   5 echo "Last command argument processed = $last_cmd_arg"
   6 # *** END DEBUG BLOCK ***

$MACHTYPE

machine type

Identifies the system hardware.

 bash$ echo $MACHTYPE
 i686
$OLDPWD

old working directory ("OLD-print-working-directory", previous directory you were in)

$OSTYPE

operating system type

 bash$ echo $OSTYPE
 linux
$PATH

path to binaries, usually /usr/bin/, /usr/X11R6/bin/, /usr/local/bin, etc.

When given a command, the shell automatically does a hash table search on the directories listed in the path for the executable. The path is stored in the environmental variable, $PATH, a list of directories, separated by colons. Normally, the system stores the $PATH definition in /etc/profile and/or ~/.bashrc (see Appendix G).

 bash$ echo $PATH
 /bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin

PATH=${PATH}:/opt/bin appends the /opt/bin directory to the current path. In a script, it may be expedient to temporarily add a directory to the path in this way. When the script exits, this restores the original $PATH (a child process, such as a script, may not change the environment of the parent process, the shell).

Note

The current "working directory", ./, is usually omitted from the $PATH as a security measure.

$PIPESTATUS

Array variable holding exit status(es) of last executed foreground pipe. Interestingly enough, this does not necessarily give the same result as the exit status of the last executed command.

 bash$ echo $PIPESTATUS
 0
 
 bash$ ls -al | bogus_command
 bash: bogus_command: command not found
 bash$ echo $PIPESTATUS
 141
 
 bash$ ls -al | bogus_command
 bash: bogus_command: command not found
 bash$ echo $?
 127
 	      

The members of the $PIPESTATUS array hold the exit status of each respective command executed in a pipe. $PIPESTATUS[0] holds the exit status of the first command in the pipe, $PIPESTATUS[1] the exit status of the second command, and so on.

Caution

The $PIPESTATUS variable may contain an erroneous 0 value in a login shell (in releases prior to 3.0 of Bash).

 tcsh% bash
 
 bash$ who | grep nobody | sort
 bash$ echo ${PIPESTATUS[*]}
 0
 	      

The above lines contained in a script would produce the expected 0 1 0 output.

Thank you, Wayne Pollock for pointing this out and supplying the above example.

Note

The $PIPESTATUS variable gives unexpected results in some contexts.

 bash$ echo $BASH_VERSION
 3.00.14(1)-release
 
 bash$ $ ls | bogus_command | wc
 bash: bogus_command: command not found
 0       0       0
 
 bash$ echo ${PIPESTATUS[@]}
 141 127 0
 	      

Chet Ramey attributes the above output to the behavior of ls. If ls writes to a pipe whose output is not read, then SIGPIPE kills it, and its exit status is 141. Otherwise its exit status is 0, as expected. This likewise is the case for tr.

Note

$PIPESTATUS is a "volatile" variable. It needs to be captured immediately after the pipe in question, before any other command intervenes.

 bash$ $ ls | bogus_command | wc
 bash: bogus_command: command not found
 0       0       0
 
 bash$ echo ${PIPESTATUS[@]}
 0 127 0
 
 bash$ echo ${PIPESTATUS[@]}
 0
 	      

Note

The pipefail option may be useful in cases where $PIPESTATUS does not give the desired information.

$PPID

The $PPID of a process is the process ID (pid) of its parent process. [1]

Compare this with the pidof command.

$PROMPT_COMMAND

A variable holding a command to be executed just before the primary prompt, $PS1 is to be displayed.

$PS1

This is the main prompt, seen at the command line.

$PS2

The secondary prompt, seen when additional input is expected. It displays as ">".

$PS3

The tertiary prompt, displayed in a select loop (see Example 10-29).

$PS4

The quartenary prompt, shown at the beginning of each line of output when invoking a script with the -x option. It displays as "+".

$PWD

working directory (directory you are in at the time)

This is the analog to the pwd builtin command.

   1 #!/bin/bash
   2 
   3 E_WRONG_DIRECTORY=73
   4 
   5 clear # Clear screen.
   6 
   7 TargetDirectory=/home/bozo/projects/GreatAmericanNovel
   8 
   9 cd $TargetDirectory
  10 echo "Deleting stale files in $TargetDirectory."
  11 
  12 if [ "$PWD" != "$TargetDirectory" ]
  13 then    # Keep from wiping out wrong directory by accident.
  14   echo "Wrong directory!"
  15   echo "In $PWD, rather than $TargetDirectory!"
  16   echo "Bailing out!"
  17   exit $E_WRONG_DIRECTORY
  18 fi  
  19 
  20 rm -rf *
  21 rm .[A-Za-z0-9]*    # Delete dotfiles.
  22 # rm -f .[^.]* ..?*   to remove filenames beginning with multiple dots.
  23 # (shopt -s dotglob; rm -f *)   will also work.
  24 # Thanks, S.C. for pointing this out.
  25 
  26 # Filenames may contain all characters in the 0 - 255 range, except "/".
  27 # Deleting files beginning with weird characters is left as an exercise.
  28 
  29 # Various other operations here, as necessary.
  30 
  31 echo
  32 echo "Done."
  33 echo "Old files deleted in $TargetDirectory."
  34 echo
  35 
  36 
  37 exit 0

$REPLY

The default value when a variable is not supplied to read. Also applicable to select menus, but only supplies the item number of the variable chosen, not the value of the variable itself.

   1 #!/bin/bash
   2 # reply.sh
   3 
   4 # REPLY is the default value for a 'read' command.
   5 
   6 echo
   7 echo -n "What is your favorite vegetable? "
   8 read
   9 
  10 echo "Your favorite vegetable is $REPLY."
  11 #  REPLY holds the value of last "read" if and only if
  12 #+ no variable supplied.
  13 
  14 echo
  15 echo -n "What is your favorite fruit? "
  16 read fruit
  17 echo "Your favorite fruit is $fruit."
  18 echo "but..."
  19 echo "Value of \$REPLY is still $REPLY."
  20 #  $REPLY is still set to its previous value because
  21 #+ the variable $fruit absorbed the new "read" value.
  22 
  23 echo
  24 
  25 exit 0

$SECONDS

The number of seconds the script has been running.

   1 #!/bin/bash
   2 
   3 TIME_LIMIT=10
   4 INTERVAL=1
   5 
   6 echo
   7 echo "Hit Control-C to exit before $TIME_LIMIT seconds."
   8 echo
   9 
  10 while [ "$SECONDS" -le "$TIME_LIMIT" ]
  11 do
  12   if [ "$SECONDS" -eq 1 ]
  13   then
  14     units=second
  15   else  
  16     units=seconds
  17   fi
  18 
  19   echo "This script has been running $SECONDS $units."
  20   #  On a slow or overburdened machine, the script may skip a count
  21   #+ every once in a while.
  22   sleep $INTERVAL
  23 done
  24 
  25 echo -e "\a"  # Beep!
  26 
  27 exit 0

$SHELLOPTS

the list of enabled shell options, a readonly variable
 bash$ echo $SHELLOPTS
 braceexpand:hashall:histexpand:monitor:history:interactive-comments:emacs
 	      

$SHLVL

Shell level, how deeply Bash is nested. [2] If, at the command line, $SHLVL is 1, then in a script it will increment to 2.

Note

This variable is not affected by subshells. Use $BASH_SUBSHELL when you need an indication of subshell nesting.

$TMOUT

If the $TMOUT environmental variable is set to a non-zero value time, then the shell prompt will time out after $time seconds. This will cause a logout.

As of version 2.05b of Bash, it is now possible to use $TMOUT in a script in combination with read.

   1 # Works in scripts for Bash, versions 2.05b and later.
   2 
   3 TMOUT=3    # Prompt times out at three seconds.
   4 
   5 echo "What is your favorite song?"
   6 echo "Quickly now, you only have $TMOUT seconds to answer!"
   7 read song
   8 
   9 if [ -z "$song" ]
  10 then
  11   song="(no answer)"
  12   # Default response.
  13 fi
  14 
  15 echo "Your favorite song is $song."

There are other, more complex, ways of implementing timed input in a script. One alternative is to set up a timing loop to signal the script when it times out. This also requires a signal handling routine to trap (see Example 29-5) the interrupt generated by the timing loop (whew!).


Example 9-2. Timed Input

   1 #!/bin/bash
   2 # timed-input.sh
   3 
   4 # TMOUT=3    Also works, as of newer versions of Bash.
   5 
   6 
   7 TIMELIMIT=3  # Three seconds in this instance. May be set to different value.
   8 
   9 PrintAnswer()
  10 {
  11   if [ "$answer" = TIMEOUT ]
  12   then
  13     echo $answer
  14   else       # Don't want to mix up the two instances. 
  15     echo "Your favorite veggie is $answer"
  16     kill $!  # Kills no longer needed TimerOn function running in background.
  17              # $! is PID of last job running in background.
  18   fi
  19 
  20 }  
  21 
  22 
  23 
  24 TimerOn()
  25 {
  26   sleep $TIMELIMIT && kill -s 14 $$ &
  27   # Waits 3 seconds, then sends sigalarm to script.
  28 }  
  29 
  30 Int14Vector()
  31 {
  32   answer="TIMEOUT"
  33   PrintAnswer
  34   exit 14
  35 }  
  36 
  37 trap Int14Vector 14   # Timer interrupt (14) subverted for our purposes.
  38 
  39 echo "What is your favorite vegetable "
  40 TimerOn
  41 read answer
  42 PrintAnswer
  43 
  44 
  45 #  Admittedly, this is a kludgy implementation of timed input,
  46 #+ however the "-t" option to "read" simplifies this task.
  47 #  See "t-out.sh", below.
  48 
  49 #  If you need something really elegant...
  50 #+ consider writing the application in C or C++,
  51 #+ using appropriate library functions, such as 'alarm' and 'setitimer'.
  52 
  53 exit 0

An alternative is using stty.


Example 9-3. Once more, timed input

   1 #!/bin/bash
   2 # timeout.sh
   3 
   4 #  Written by Stephane Chazelas,
   5 #+ and modified by the document author.
   6 
   7 INTERVAL=5                # timeout interval
   8 
   9 timedout_read() {
  10   timeout=$1
  11   varname=$2
  12   old_tty_settings=`stty -g`
  13   stty -icanon min 0 time ${timeout}0
  14   eval read $varname      # or just  read $varname
  15   stty "$old_tty_settings"
  16   # See man page for "stty".
  17 }
  18 
  19 echo; echo -n "What's your name? Quick! "
  20 timedout_read $INTERVAL your_name
  21 
  22 #  This may not work on every terminal type.
  23 #  The maximum timeout depends on the terminal.
  24 #+ (it is often 25.5 seconds).
  25 
  26 echo
  27 
  28 if [ ! -z "$your_name" ]  # If name input before timeout...
  29 then
  30   echo "Your name is $your_name."
  31 else
  32   echo "Timed out."
  33 fi
  34 
  35 echo
  36 
  37 # The behavior of this script differs somewhat from "timed-input.sh".
  38 # At each keystroke, the counter resets.
  39 
  40 exit 0

Perhaps the simplest method is using the -t option to read.


Example 9-4. Timed read

   1 #!/bin/bash
   2 # t-out.sh
   3 # Inspired by a suggestion from "syngin seven" (thanks).
   4 
   5 
   6 TIMELIMIT=4         # 4 seconds
   7 
   8 read -t $TIMELIMIT variable <&1
   9 #                           ^^^
  10 #  In this instance, "<&1" is needed for Bash 1.x and 2.x,
  11 #  but unnecessary for Bash 3.x.
  12 
  13 echo
  14 
  15 if [ -z "$variable" ]  # Is null?
  16 then
  17   echo "Timed out, variable still unset."
  18 else  
  19   echo "variable = $variable"
  20 fi  
  21 
  22 exit 0

$UID

user ID number

current user's user identification number, as recorded in /etc/passwd

This is the current user's real id, even if she has temporarily assumed another identity through su. $UID is a readonly variable, not subject to change from the command line or within a script, and is the counterpart to the id builtin.


Example 9-5. Am I root?

   1 #!/bin/bash
   2 # am-i-root.sh:   Am I root or not?
   3 
   4 ROOT_UID=0   # Root has $UID 0.
   5 
   6 if [ "$UID" -eq "$ROOT_UID" ]  # Will the real "root" please stand up?
   7 then
   8   echo "You are root."
   9 else
  10   echo "You are just an ordinary user (but mom loves you just the same)."
  11 fi
  12 
  13 exit 0
  14 
  15 
  16 # ============================================================= #
  17 # Code below will not execute, because the script already exited.
  18 
  19 # An alternate method of getting to the root of matters:
  20 
  21 ROOTUSER_NAME=root
  22 
  23 username=`id -nu`              # Or...   username=`whoami`
  24 if [ "$username" = "$ROOTUSER_NAME" ]
  25 then
  26   echo "Rooty, toot, toot. You are root."
  27 else
  28   echo "You are just a regular fella."
  29 fi

See also Example 2-3.

Note

The variables $ENV, $LOGNAME, $MAIL, $TERM, $USER, and $USERNAME are not Bash builtins. These are, however, often set as environmental variables in one of the Bash startup files. $SHELL, the name of the user's login shell, may be set from /etc/passwd or in an "init" script, and it is likewise not a Bash builtin.

 tcsh% echo $LOGNAME
 bozo
 tcsh% echo $SHELL
 /bin/tcsh
 tcsh% echo $TERM
 rxvt
 
 bash$ echo $LOGNAME
 bozo
 bash$ echo $SHELL
 /bin/tcsh
 bash$ echo $TERM
 rxvt
 	      

Positional Parameters

$0, $1, $2, etc.

positional parameters, passed from command line to script, passed to a function, or set to a variable (see Example 4-5 and Example 14-15)

$#

number of command line arguments [3] or positional parameters (see Example 33-2)

$*

All of the positional parameters, seen as a single word

Note

"$*" must be quoted.

$@

Same as $*, but each parameter is a quoted string, that is, the parameters are passed on intact, without interpretation or expansion. This means, among other things, that each parameter in the argument list is seen as a separate word.

Note

Of course, "$@" should be quoted.


Example 9-6. arglist: Listing arguments with $* and $@

   1 #!/bin/bash
   2 # arglist.sh
   3 # Invoke this script with several arguments, such as "one two three".
   4 
   5 E_BADARGS=65
   6 
   7 if [ ! -n "$1" ]
   8 then
   9   echo "Usage: `basename $0` argument1 argument2 etc."
  10   exit $E_BADARGS
  11 fi  
  12 
  13 echo
  14 
  15 index=1          # Initialize count.
  16 
  17 echo "Listing args with \"\$*\":"
  18 for arg in "$*"  # Doesn't work properly if "$*" isn't quoted.
  19 do
  20   echo "Arg #$index = $arg"
  21   let "index+=1"
  22 done             # $* sees all arguments as single word. 
  23 echo "Entire arg list seen as single word."
  24 
  25 echo
  26 
  27 index=1          # Reset count.
  28                  # What happens if you forget to do this?
  29 
  30 echo "Listing args with \"\$@\":"
  31 for arg in "$@"
  32 do
  33   echo "Arg #$index = $arg"
  34   let "index+=1"
  35 done             # $@ sees arguments as separate words. 
  36 echo "Arg list seen as separate words."
  37 
  38 echo
  39 
  40 index=1          # Reset count.
  41 
  42 echo "Listing args with \$* (unquoted):"
  43 for arg in $*
  44 do
  45   echo "Arg #$index = $arg"
  46   let "index+=1"
  47 done             # Unquoted $* sees arguments as separate words. 
  48 echo "Arg list seen as separate words."
  49 
  50 exit 0

Following a shift, the $@ holds the remaining command-line parameters, lacking the previous $1, which was lost.
   1 #!/bin/bash
   2 # Invoke with ./scriptname 1 2 3 4 5
   3 
   4 echo "$@"    # 1 2 3 4 5
   5 shift
   6 echo "$@"    # 2 3 4 5
   7 shift
   8 echo "$@"    # 3 4 5
   9 
  10 # Each "shift" loses parameter $1.
  11 # "$@" then contains the remaining parameters.

The $@ special parameter finds use as a tool for filtering input into shell scripts. The cat "$@" construction accepts input to a script either from stdin or from files given as parameters to the script. See Example 15-21 and Example 15-22.

Caution

The $* and $@ parameters sometimes display inconsistent and puzzling behavior, depending on the setting of $IFS.


Example 9-7. Inconsistent $* and $@ behavior

   1 #!/bin/bash
   2 
   3 #  Erratic behavior of the "$*" and "$@" internal Bash variables,
   4 #+ depending on whether they are quoted or not.
   5 #  Inconsistent handling of word splitting and linefeeds.
   6 
   7 
   8 set -- "First one" "second" "third:one" "" "Fifth: :one"
   9 # Setting the script arguments, $1, $2, etc.
  10 
  11 echo
  12 
  13 echo 'IFS unchanged, using "$*"'
  14 c=0
  15 for i in "$*"               # quoted
  16 do echo "$((c+=1)): [$i]"   # This line remains the same in every instance.
  17                             # Echo args.
  18 done
  19 echo ---
  20 
  21 echo 'IFS unchanged, using $*'
  22 c=0
  23 for i in $*                 # unquoted
  24 do echo "$((c+=1)): [$i]"
  25 done
  26 echo ---
  27 
  28 echo 'IFS unchanged, using "$@"'
  29 c=0
  30 for i in "$@"
  31 do echo "$((c+=1)): [$i]"
  32 done
  33 echo ---
  34 
  35 echo 'IFS unchanged, using $@'
  36 c=0
  37 for i in $@
  38 do echo "$((c+=1)): [$i]"
  39 done
  40 echo ---
  41 
  42 IFS=:
  43 echo 'IFS=":", using "$*"'
  44 c=0
  45 for i in "$*"
  46 do echo "$((c+=1)): [$i]"
  47 done
  48 echo ---
  49 
  50 echo 'IFS=":", using $*'
  51 c=0
  52 for i in $*
  53 do echo "$((c+=1)): [$i]"
  54 done
  55 echo ---
  56 
  57 var=$*
  58 echo 'IFS=":", using "$var" (var=$*)'
  59 c=0
  60 for i in "$var"
  61 do echo "$((c+=1)): [$i]"
  62 done
  63 echo ---
  64 
  65 echo 'IFS=":", using $var (var=$*)'
  66 c=0
  67 for i in $var
  68 do echo "$((c+=1)): [$i]"
  69 done
  70 echo ---
  71 
  72 var="$*"
  73 echo 'IFS=":", using $var (var="$*")'
  74 c=0
  75 for i in $var
  76 do echo "$((c+=1)): [$i]"
  77 done
  78 echo ---
  79 
  80 echo 'IFS=":", using "$var" (var="$*")'
  81 c=0
  82 for i in "$var"
  83 do echo "$((c+=1)): [$i]"
  84 done
  85 echo ---
  86 
  87 echo 'IFS=":", using "$@"'
  88 c=0
  89 for i in "$@"
  90 do echo "$((c+=1)): [$i]"
  91 done
  92 echo ---
  93 
  94 echo 'IFS=":", using $@'
  95 c=0
  96 for i in $@
  97 do echo "$((c+=1)): [$i]"
  98 done
  99 echo ---
 100 
 101 var=$@
 102 echo 'IFS=":", using $var (var=$@)'
 103 c=0
 104 for i in $var
 105 do echo "$((c+=1)): [$i]"
 106 done
 107 echo ---
 108 
 109 echo 'IFS=":", using "$var" (var=$@)'
 110 c=0
 111 for i in "$var"
 112 do echo "$((c+=1)): [$i]"
 113 done
 114 echo ---
 115 
 116 var="$@"
 117 echo 'IFS=":", using "$var" (var="$@")'
 118 c=0
 119 for i in "$var"
 120 do echo "$((c+=1)): [$i]"
 121 done
 122 echo ---
 123 
 124 echo 'IFS=":", using $var (var="$@")'
 125 c=0
 126 for i in $var
 127 do echo "$((c+=1)): [$i]"
 128 done
 129 
 130 echo
 131 
 132 # Try this script with ksh or zsh -y.
 133 
 134 exit 0
 135 
 136 # This example script by Stephane Chazelas,
 137 # and slightly modified by the document author.

Note

The $@ and $* parameters differ only when between double quotes.


Example 9-8. $* and $@ when $IFS is empty

   1 #!/bin/bash
   2 
   3 #  If $IFS set, but empty,
   4 #+ then "$*" and "$@" do not echo positional params as expected.
   5 
   6 mecho ()       # Echo positional parameters.
   7 {
   8 echo "$1,$2,$3";
   9 }
  10 
  11 
  12 IFS=""         # Set, but empty.
  13 set a b c      # Positional parameters.
  14 
  15 mecho "$*"     # abc,,
  16 mecho $*       # a,b,c
  17 
  18 mecho $@       # a,b,c
  19 mecho "$@"     # a,b,c
  20 
  21 #  The behavior of $* and $@ when $IFS is empty depends
  22 #+ on whatever Bash or sh version being run.
  23 #  It is therefore inadvisable to depend on this "feature" in a script.
  24 
  25 
  26 # Thanks, Stephane Chazelas.
  27 
  28 exit 0

Other Special Parameters

$-

Flags passed to script (using set). See Example 14-15.

Caution

This was originally a ksh construct adopted into Bash, and unfortunately it does not seem to work reliably in Bash scripts. One possible use for it is to have a script self-test whether it is interactive.

$!

PID (process ID) of last job run in background

   1 LOG=$0.log
   2 
   3 COMMAND1="sleep 100"
   4 
   5 echo "Logging PIDs background commands for script: $0" >> "$LOG"
   6 # So they can be monitored, and killed as necessary.
   7 echo >> "$LOG"
   8 
   9 # Logging commands.
  10 
  11 echo -n "PID of \"$COMMAND1\":  " >> "$LOG"
  12 ${COMMAND1} &
  13 echo $! >> "$LOG"
  14 # PID of "sleep 100":  1506
  15 
  16 # Thank you, Jacques Lederer, for suggesting this.

Using $! for job control:

   1 possibly_hanging_job & { sleep ${TIMEOUT}; eval 'kill -9 $!' &> /dev/null; }
   2 # Forces completion of an ill-behaved program.
   3 # Useful, for example, in init scripts.
   4 
   5 # Thank you, Sylvain Fourmanoit, for this creative use of the "!" variable.

Or, alternately:

   1 # This example by Matthew Sage.
   2 # Used with permission.
   3 
   4 TIMEOUT=30   # Timeout value in seconds
   5 count=0
   6 
   7 possibly_hanging_job & {
   8         while ((count < TIMEOUT )); do
   9                 eval '[ ! -d "/proc/$!" ] && ((count = TIMEOUT))'
  10                 # /proc is where information about running processes is found.
  11                 # "-d" tests whether it exists (whether directory exists).
  12                 # So, we're waiting for the job in question to show up.
  13                 ((count++))
  14                 sleep 1
  15         done
  16         eval '[ -d "/proc/$!" ] && kill -15 $!'
  17         # If the hanging job is running, kill it.
  18 }

$_

Special variable set to last argument of previous command executed.


Example 9-9. Underscore variable

   1 #!/bin/bash
   2 
   3 echo $_              # /bin/bash
   4                      # Just called /bin/bash to run the script.
   5 
   6 du >/dev/null        # So no output from command.
   7 echo $_              # du
   8 
   9 ls -al >/dev/null    # So no output from command.
  10 echo $_              # -al  (last argument)
  11 
  12 :
  13 echo $_              # :

$?

Exit status of a command, function, or the script itself (see Example 23-7)

$$

Process ID of the script itself. The $$ variable often finds use in scripts to construct "unique" temp file names (see Example A-13, Example 29-6, Example 15-28, and Example 14-26). This is usually simpler than invoking mktemp.

Notes

[1]

The PID of the currently running script is $$, of course.

[2]

Somewhat analogous to recursion, in this context nesting refers to a pattern embedded within a larger pattern. One of the definitions of nest, according to the 1913 edition of Webster's Dictionary, is "A collection of boxes, cases, or the like, of graduated size, each put within the one next larger."

[3]

The words "argument" and "parameter" are often used interchangeably. In the context of this document, they have the same precise meaning, that of a variable passed to a script or function.