I/O

echo

prints (to stdout) an expression or variable (see Example 4-1).

1 echo Hello 2 echo $a

An echo requires the -e option to print escaped characters. See Example 5-2.

Normally, each echo command prints a terminal newline, but the -n option suppresses this.

An echo can be used to feed a sequence of commands down a pipe. 1 if echo "$VAR" | grep -q txt # if [[ $VAR = *txt* ]] 2 then 3  echo "$VAR contains the substring sequence \"txt\"" 4 fi

An echo, in combination with command substitution can set a variable. a=`echo "HELLO" | tr A-Z a-z` See also Example 15-20, Example 15-3, Example 15-43, and Example 15-44.

Be aware that echo `command` deletes any linefeeds that the output of command generates.

The $IFS (internal field separator) variable normally contains \n (linefeed) as one of its set of whitespace characters. Bash therefore splits the output of command at linefeeds into arguments to echo. Then echo outputs these arguments, separated by spaces.

bash$ ls -l /usr/share/apps/kjezz/sounds -rw-r--r-- 1 root root 1407 Nov 7 2000 reflect.au -rw-r--r-- 1 root root 362 Nov 7 2000 seconds.au bash$ echo `ls -l /usr/share/apps/kjezz/sounds` total 40 -rw-r--r-- 1 root root 716 Nov 7 2000 reflect.au -rw-r--r-- 1 root root ...

So, how can we embed a linefeed within an echoed character string?

1 # Embedding a linefeed? 2 echo "Why doesn't this string \n split on two lines?" 3 # Doesn't split. 4  5 # Let's try something else. 6  7 echo 8  9 echo $"A line of text containing 10 a linefeed." 11 # Prints as two distinct lines (embedded linefeed). 12 # But, is the "$" variable prefix really necessary? 13  14 echo 15  16 echo "This string splits 17 on two lines." 18 # No, the "$" is not needed. 19  20 echo 21 echo "---------------" 22 echo 23  24 echo -n $"Another line of text containing 25 a linefeed." 26 # Prints as two distinct lines (embedded linefeed). 27 # Even the -n option fails to suppress the linefeed here. 28  29 echo 30 echo 31 echo "---------------" 32 echo 33 echo 34  35 # However, the following doesn't work as expected. 36 # Why not? Hint: Assignment to a variable. 37 string1=$"Yet another line of text containing 38 a linefeed (maybe)." 39  40 echo $string1 41 # Yet another line of text containing a linefeed (maybe). 42 # ^ 43 # Linefeed becomes a space. 44  45 # Thanks, Steve Parker, for pointing this out.

This command is a shell builtin, and not the same as /bin/echo, although its behavior is similar. bash$ type -a echo echo is a shell builtin echo is /bin/echo

printf

The printf, formatted print, command is an enhanced echo. It is a limited variant of the C language printf() library function, and its syntax is somewhat different.

printf format-string... parameter...

This is the Bash builtin version of the /bin/printf or /usr/bin/printf command. See the printf manpage (of the system command) for in-depth coverage.

Older versions of Bash may not support printf.

---

Example 14-2. printf in action

1 #!/bin/bash 2 # printf demo 3  4 PI=3.14159265358979 5 DecimalConstant=31373 6 Message1="Greetings," 7 Message2="Earthling." 8  9 echo 10  11 printf "Pi to 2 decimal places = %1.2f" $PI 12 echo 13 printf "Pi to 9 decimal places = %1.9f" $PI # It even rounds off correctly. 14  15 printf "\n" # Prints a line feed, 16  # Equivalent to 'echo' . . . 17  18 printf "Constant = \t%d\n" $DecimalConstant # Inserts tab (\t). 19  20 printf "%s %s \n" $Message1 $Message2 21  22 echo 23  24 # ==========================================# 25 # Simulation of C function, sprintf(). 26 # Loading a variable with a formatted string. 27  28 echo 29  30 Pi12=$(printf "%1.12f" $PI) 31 echo "Pi to 12 decimal places = $Pi12" 32  33 Msg=`printf "%s %s \n" $Message1 $Message2` 34 echo $Msg; echo $Msg 35  36 # As it happens, the 'sprintf' function can now be accessed 37 #+ as a loadable module to Bash, 38 #+ but this is not portable. 39  40 exit 0

---

Formatting error messages is a useful application of printf

1 E_BADDIR=65 2  3 var=nonexistent_directory 4  5 error() 6 { 7  printf "$@" >&2 8  # Formats positional params passed, and sends them to stderr. 9  echo 10  exit $E_BADDIR 11 } 12  13 cd $var || error $"Can't cd to %s." "$var" 14  15 # Thanks, S.C.

read

"Reads" the value of a variable from stdin, that is, interactively fetches input from the keyboard. The -a option lets read get array variables (see Example 26-6).

---

Example 14-3. Variable assignment, using read

1 #!/bin/bash 2 # "Reading" variables. 3  4 echo -n "Enter the value of variable 'var1': " 5 # The -n option to echo suppresses newline. 6  7 read var1 8 # Note no '$' in front of var1, since it is being set. 9  10 echo "var1 = $var1" 11  12  13 echo 14  15 # A single 'read' statement can set multiple variables. 16 echo -n "Enter the values of variables 'var2' and 'var3' " 17 echo =n "(separated by a space or tab): " 18 read var2 var3 19 echo "var2 = $var2 var3 = $var3" 20 # If you input only one value, 21 #+ the other variable(s) will remain unset (null). 22  23 exit 0

---

A read without an associated variable assigns its input to the dedicated variable $REPLY.

---

Example 14-4. What happens when read has no variable

1 #!/bin/bash 2 # read-novar.sh 3  4 echo 5  6 # -------------------------- # 7 echo -n "Enter a value: " 8 read var 9 echo "\"var\" = "$var"" 10 # Everything as expected here. 11 # -------------------------- # 12  13 echo 14  15 # ------------------------------------------------------------------- # 16 echo -n "Enter another value: " 17 read # No variable supplied for 'read', therefore... 18  #+ Input to 'read' assigned to default variable, $REPLY. 19 var="$REPLY" 20 echo "\"var\" = "$var"" 21 # This is equivalent to the first code block. 22 # ------------------------------------------------------------------- # 23  24 echo 25 echo "=========================" 26 echo 27  28  29 # This example is similar to the "reply.sh" script. 30 # However, this one shows that $REPLY is available 31 #+ even after a 'read' to a variable in the conventional way. 32  33  34 # ================================================================= # 35  36 # In some instances, you might wish to discard the first value read. 37 # In such cases, simply ignore the $REPLY variable. 38  39 { # Code block. 40 read # Line 1, to be discarded. 41 read line2 # Line 2, saved in variable. 42  } <$0 43 echo "Line 2 of this script is:" 44 echo "$line2" # # read-novar.sh 45 echo # #!/bin/bash line discarded. 46  47 # See also the soundcard-on.sh script. 48  49 exit 0

---

Normally, inputting a \ suppresses a newline during input to a read. The -r option causes an inputted \ to be interpreted literally.

---

Example 14-5. Multi-line input to read

1 #!/bin/bash 2  3 echo 4  5 echo "Enter a string terminated by a \\, then press <ENTER>." 6 echo "Then, enter a second string (no \\ this time), and again press <ENTER>." 7  8 read var1 # The "\" suppresses the newline, when reading $var1. 9  # first line \ 10  # second line 11  12 echo "var1 = $var1" 13 # var1 = first line second line 14  15 # For each line terminated by a "\" 16 #+ you get a prompt on the next line to continue feeding characters into var1. 17  18 echo; echo 19  20 echo "Enter another string terminated by a \\ , then press <ENTER>." 21 read -r var2 # The -r option causes the "\" to be read literally. 22  # first line \ 23  24 echo "var2 = $var2" 25 # var2 = first line \ 26  27 # Data entry terminates with the first <ENTER>. 28  29 echo 30  31 exit 0

---

The read command has some interesting options that permit echoing a prompt and even reading keystrokes without hitting ENTER.

1 # Read a keypress without hitting ENTER. 2  3 read -s -n1 -p "Hit a key " keypress 4 echo; echo "Keypress was "\"$keypress\""." 5  6 # -s option means do not echo input. 7 # -n N option means accept only N characters of input. 8 # -p option means echo the following prompt before reading input. 9  10 # Using these options is tricky, since they need to be in the correct order.

The -n option to read also allows detection of the arrow keys and certain of the other unusual keys.

---

Example 14-6. Detecting the arrow keys

1 #!/bin/bash 2 # arrow-detect.sh: Detects the arrow keys, and a few more. 3 # Thank you, Sandro Magi, for showing me how. 4  5 # -------------------------------------------- 6 # Character codes generated by the keypresses. 7 arrowup='\[A' 8 arrowdown='\[B' 9 arrowrt='\[C' 10 arrowleft='\[D' 11 insert='\[2' 12 delete='\[3' 13 # -------------------------------------------- 14  15 SUCCESS=0 16 OTHER=65 17  18 echo -n "Press a key... " 19 # May need to also press ENTER if a key not listed above pressed. 20 read -n3 key # Read 3 characters. 21  22 echo -n "$key" | grep "$arrowup" #Check if character code detected. 23 if [ "$?" -eq $SUCCESS ] 24 then 25  echo "Up-arrow key pressed." 26  exit $SUCCESS 27 fi 28  29 echo -n "$key" | grep "$arrowdown" 30 if [ "$?" -eq $SUCCESS ] 31 then 32  echo "Down-arrow key pressed." 33  exit $SUCCESS 34 fi 35  36 echo -n "$key" | grep "$arrowrt" 37 if [ "$?" -eq $SUCCESS ] 38 then 39  echo "Right-arrow key pressed." 40  exit $SUCCESS 41 fi 42  43 echo -n "$key" | grep "$arrowleft" 44 if [ "$?" -eq $SUCCESS ] 45 then 46  echo "Left-arrow key pressed." 47  exit $SUCCESS 48 fi 49  50 echo -n "$key" | grep "$insert" 51 if [ "$?" -eq $SUCCESS ] 52 then 53  echo "\"Insert\" key pressed." 54  exit $SUCCESS 55 fi 56  57 echo -n "$key" | grep "$delete" 58 if [ "$?" -eq $SUCCESS ] 59 then 60  echo "\"Delete\" key pressed." 61  exit $SUCCESS 62 fi 63  64  65 echo " Some other key pressed." 66  67 exit $OTHER 68  69 # ========================================= # 70  71 # Mark Alexander came up with a simplified 72 #+ version of the above script (Thank you!). 73 # It eliminates the need for grep. 74  75 #!/bin/bash 76  77  uparrow=$'\x1b[A' 78  downarrow=$'\x1b[B' 79  leftarrow=$'\x1b[D' 80  rightarrow=$'\x1b[C' 81  82  read -s -n3 -p "Hit an arrow key: " x 83  84  case "$x" in 85  $uparrow) 86  echo "You pressed up-arrow" 87  ;; 88  $downarrow) 89  echo "You pressed down-arrow" 90  ;; 91  $leftarrow) 92  echo "You pressed left-arrow" 93  ;; 94  $rightarrow) 95  echo "You pressed right-arrow" 96  ;; 97  esac 98  99 # ========================================= # 100  101 # Exercise: 102 # -------- 103 # 1) Add detection of the "Home," "End," "PgUp," and "PgDn" keys.

---

The -n option to read will not detect the ENTER (newline) key.

The -t option to read permits timed input (see Example 9-4).

The read command may also "read" its variable value from a file redirected to stdin. If the file contains more than one line, only the first line is assigned to the variable. If read has more than one parameter, then each of these variables gets assigned a successive whitespace-delineated string. Caution!

---

Example 14-7. Using read with file redirection

1 #!/bin/bash 2  3 read var1 <data-file 4 echo "var1 = $var1" 5 # var1 set to the entire first line of the input file "data-file" 6  7 read var2 var3 <data-file 8 echo "var2 = $var2 var3 = $var3" 9 # Note non-intuitive behavior of "read" here. 10 # 1) Rewinds back to the beginning of input file. 11 # 2) Each variable is now set to a corresponding string, 12 # separated by whitespace, rather than to an entire line of text. 13 # 3) The final variable gets the remainder of the line. 14 # 4) If there are more variables to be set than whitespace-terminated strings 15 # on the first line of the file, then the excess variables remain empty. 16  17 echo "------------------------------------------------" 18  19 # How to resolve the above problem with a loop: 20 while read line 21 do 22  echo "$line" 23 done <data-file 24 # Thanks, Heiner Steven for pointing this out. 25  26 echo "------------------------------------------------" 27  28 # Use $IFS (Internal Field Separator variable) to split a line of input to 29 # "read", if you do not want the default to be whitespace. 30  31 echo "List of all users:" 32 OIFS=$IFS; IFS=: # /etc/passwd uses ":" for field separator. 33 while read name passwd uid gid fullname ignore 34 do 35  echo "$name ($fullname)" 36 done </etc/passwd # I/O redirection. 37 IFS=$OIFS # Restore original $IFS. 38 # This code snippet also by Heiner Steven. 39  40  41  42 # Setting the $IFS variable within the loop itself 43 #+ eliminates the need for storing the original $IFS 44 #+ in a temporary variable. 45 # Thanks, Dim Segebart, for pointing this out. 46 echo "------------------------------------------------" 47 echo "List of all users:" 48  49 while IFS=: read name passwd uid gid fullname ignore 50 do 51  echo "$name ($fullname)" 52 done </etc/passwd # I/O redirection. 53  54 echo 55 echo "\$IFS still $IFS" 56  57 exit 0

---

Piping output to a read, using echo to set variables will fail. Yet, piping the output of cat seems to work. 1 cat file1 file2 | 2 while read line 3 do 4 echo $line 5 done However, as Bjön Eriksson shows: Example 14-8. Problems reading from a pipe 1 #!/bin/sh 2 # readpipe.sh 3 # This example contributed by Bjon Eriksson. 4  5 last="(null)" 6 cat $0 | 7 while read line 8 do 9  echo "{$line}" 10  last=$line 11 done 12 printf "\nAll done, last:$last\n" 13  14 exit 0 # End of code. 15  # (Partial) output of script follows. 16  # The 'echo' supplies extra brackets. 17  18 ############################################# 19  20 ./readpipe.sh 21  22 {#!/bin/sh} 23 {last="(null)"} 24 {cat $0 |} 25 {while read line} 26 {do} 27 {echo "{$line}"} 28 {last=$line} 29 {done} 30 {printf "nAll done, last:$lastn"} 31  32  33 All done, last:(null) 34  35 The variable (last) is set within the subshell but unset outside. The gendiff script, usually found in /usr/bin on many Linux distros, pipes the output of find to a while read construct. 1 find $1 \( -name "*$2" -o -name ".*$2" \) -print | 2 while read f; do 3 . . .

It is possible to paste text into the input field of a read. See Example A-38.

Filesystem

cd

The familiar cd change directory command finds use in scripts where execution of a command requires being in a specified directory.

1 (cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)

[from the previously cited example by Alan Cox]

The -P (physical) option to cd causes it to ignore symbolic links.

cd - changes to $OLDPWD, the previous working directory.

The cd command does not function as expected when presented with two forward slashes. bash$ cd // bash$ pwd // The output should, of course, be /. This is a problem both from the command line and in a script.

pwd

Print Working Directory. This gives the user's (or script's) current directory (see Example 14-9). The effect is identical to reading the value of the builtin variable $PWD.

pushd, popd, dirs

This command set is a mechanism for bookmarking working directories, a means of moving back and forth through directories in an orderly manner. A pushdown stack is used to keep track of directory names. Options allow various manipulations of the directory stack.

pushd dir-name pushes the path dir-name onto the directory stack and simultaneously changes the current working directory to dir-name

popd removes (pops) the top directory path name off the directory stack and simultaneously changes the current working directory to that directory popped from the stack.

dirs lists the contents of the directory stack (compare this with the $DIRSTACK variable). A successful pushd or popd will automatically invoke dirs.

Scripts that require various changes to the current working directory without hard-coding the directory name changes can make good use of these commands. Note that the implicit $DIRSTACK array variable, accessible from within a script, holds the contents of the directory stack.

---

Example 14-9. Changing the current working directory

1 #!/bin/bash 2  3 dir1=/usr/local 4 dir2=/var/spool 5  6 pushd $dir1 7 # Will do an automatic 'dirs' (list directory stack to stdout). 8 echo "Now in directory `pwd`." # Uses back-quoted 'pwd'. 9  10 # Now, do some stuff in directory 'dir1'. 11 pushd $dir2 12 echo "Now in directory `pwd`." 13  14 # Now, do some stuff in directory 'dir2'. 15 echo "The top entry in the DIRSTACK array is $DIRSTACK." 16 popd 17 echo "Now back in directory `pwd`." 18  19 # Now, do some more stuff in directory 'dir1'. 20 popd 21 echo "Now back in original working directory `pwd`." 22  23 exit 0 24  25 # What happens if you don't 'popd' -- then exit the script? 26 # Which directory do you end up in? Why?

---

Variables

let

The let command carries out arithmetic operations on variables. In many cases, it functions as a less complex version of expr.

---

Example 14-10. Letting let do arithmetic.

1 #!/bin/bash 2  3 echo 4  5 let a=11 # Same as 'a=11' 6 let a=a+5 # Equivalent to let "a = a + 5" 7  # (Double quotes and spaces make it more readable.) 8 echo "11 + 5 = $a" # 16 9  10 let "a <<= 3" # Equivalent to let "a = a << 3" 11 echo "\"\$a\" (=16) left-shifted 3 places = $a" 12  # 128 13  14 let "a /= 4" # Equivalent to let "a = a / 4" 15 echo "128 / 4 = $a" # 32 16  17 let "a -= 5" # Equivalent to let "a = a - 5" 18 echo "32 - 5 = $a" # 27 19  20 let "a *= 10" # Equivalent to let "a = a * 10" 21 echo "27 * 10 = $a" # 270 22  23 let "a %= 8" # Equivalent to let "a = a % 8" 24 echo "270 modulo 8 = $a (270 / 8 = 33, remainder $a)" 25  # 6 26  27 echo 28  29 exit 0

---

eval

eval arg1 [arg2] ... [argN]

Combines the arguments in an expression or list of expressions and evaluates them. Any variables contained within the expression are expanded. The result translates into a command. This can be useful for code generation from the command line or within a script.

bash$ process=xterm bash$ show_process="eval ps ax | grep $process" bash$ $show_process 1867 tty1 S 0:02 xterm 2779 tty1 S 0:00 xterm 2886 pts/1 S 0:00 grep xterm

---

Example 14-11. Showing the effect of eval

1 #!/bin/bash 2  3 y=`eval ls -l` # Similar to y=`ls -l` 4 echo $y #+ but linefeeds removed because "echoed" variable is unquoted. 5 echo 6 echo "$y" # Linefeeds preserved when variable is quoted. 7  8 echo; echo 9  10 y=`eval df` # Similar to y=`df` 11 echo $y #+ but linefeeds removed. 12  13 # When LF's not preserved, it may make it easier to parse output, 14 #+ using utilities such as "awk". 15  16 echo 17 echo "===========================================================" 18 echo 19  20 # Now, showing how to "expand" a variable using "eval" . . . 21  22 for i in 1 2 3 4 5; do 23  eval value=$i 24  # value=$i has same effect. The "eval" is not necessary here. 25  # A variable lacking a meta-meaning evaluates to itself -- 26  #+ it can't expand to anything other than its literal self. 27  echo $value 28 done 29  30 echo 31 echo "---" 32 echo 33  34 for i in ls df; do 35  value=eval $i 36  # value=$i has an entirely different effect here. 37  # The "eval" evaluates the commands "ls" and "df" . . . 38  # The terms "ls" and "df" have a meta-meaning, 39  #+ since they are interpreted as commands, 40  #+ rather than just character strings. 41  echo $value 42 done 43  44  45 exit 0

---

---

Example 14-12. Echoing the command-line parameters

1 #!/bin/bash 2 # echo-params.sh 3  4 # Call this script with a few command line parameters. 5 # For example: 6 # sh echo-params.sh first second third fourth fifth 7  8 params=$# # Number of command-line parameters. 9 param=1 # Start at first command-line param. 10  11 while [ "$param" -le "$params" ] 12 do 13  echo -n "Command line parameter " 14  echo -n \$$param # Gives only the *name* of variable. 15 # ^^^ # $1, $2, $3, etc. 16  # Why? 17  # \$ escapes the first "$" 18  #+ so it echoes literally, 19  #+ and $param dereferences "$param" . . . 20  #+ . . . as expected. 21  echo -n " = " 22  eval echo \$$param # Gives the *value* of variable. 23 # ^^^^ ^^^ # The "eval" forces the *evaluation* 24  #+ of \$$ 25  #+ as an indirect variable reference. 26  27 (( param ++ )) # On to the next. 28 done 29  30 exit $? 31  32 # ================================================= 33  34 $ sh echo-params.sh first second third fourth fifth 35 Command line parameter $1 = first 36 Command line parameter $2 = second 37 Command line parameter $3 = third 38 Command line parameter $4 = fourth 39 Command line parameter $5 = fifth

---

---

Example 14-13. Forcing a log-off

1 #!/bin/bash 2 # Killing ppp to force a log-off. 3  4 # Script should be run as root user. 5  6 killppp="eval kill -9 `ps ax | awk '/ppp/ { print $1 }'`" 7 # -------- process ID of ppp ------- 8  9 $killppp # This variable is now a command. 10  11  12 # The following operations must be done as root user. 13  14 chmod 666 /dev/ttyS3 # Restore read+write permissions, or else what? 15 # Since doing a SIGKILL on ppp changed the permissions on the serial port, 16 #+ we restore permissions to previous state. 17  18 rm /var/lock/LCK..ttyS3 # Remove the serial port lock file. Why? 19  20 # Note: 21 # Depending on the hardware and even the kernel version, 22 #+ the modem port on your machine may be different -- 23 #+ /dev/ttyS1 or /dev/ttyS2. 24  25 exit 0 26  27 # Exercises: 28 # --------- 29 # 1) Have script check whether root user is invoking it. 30 # 2) Do a check on whether the process to be killed 31 #+ is actually running before attempting to kill it. 32 # 3) Write an alternate version of this script based on 'fuser': 33 #+ if [ fuser -s /dev/modem ]; then . . .

---

---

Example 14-14. A version of rot13

1 #!/bin/bash 2 # A version of "rot13" using 'eval'. 3 # Compare to "rot13.sh" example. 4  5 setvar_rot_13() # "rot13" scrambling 6 { 7  local varname=$1 varvalue=$2 8  eval $varname='$(echo "$varvalue" | tr a-z n-za-m)' 9 } 10  11  12 setvar_rot_13 var "foobar" # Run "foobar" through rot13. 13 echo $var # sbbone 14  15 setvar_rot_13 var "$var" # Run "sbbone" through rot13. 16  # Back to original variable. 17 echo $var # foobar 18  19 # This example by Stephane Chazelas. 20 # Modified by document author. 21  22 exit 0

---

Rory Winston contributed the following instance of how useful eval can be.

---

Example 14-15. Using eval to force variable substitution in a Perl script

1 In the Perl script "test.pl": 2  ... 3  my $WEBROOT = <WEBROOT_PATH>; 4  ... 5  6 To force variable substitution try: 7  $export WEBROOT_PATH=/usr/local/webroot 8  $sed 's/<WEBROOT_PATH>/$WEBROOT_PATH/' < test.pl > out 9  10 But this just gives: 11  my $WEBROOT = $WEBROOT_PATH; 12  13 However: 14  $export WEBROOT_PATH=/usr/local/webroot 15  $eval sed 's%\<WEBROOT_PATH\>%$WEBROOT_PATH%' < test.pl > out 16 # ==== 17  18 That works fine, and gives the expected substitution: 19  my $WEBROOT = /usr/local/webroot; 20  21  22 ### Correction applied to original example by Paulo Marcel Coelho Aragao.

---

The eval command can be risky, and normally should be avoided when there exists a reasonable alternative. An eval $COMMANDS executes the contents of COMMANDS, which may contain such unpleasant surprises as rm -rf *. Running an eval on unfamiliar code written by persons unknown is living dangerously.

set

The set command changes the value of internal script variables/options. One use for this is to toggle option flags which help determine the behavior of the script. Another application for it is to reset the positional parameters that a script sees as the result of a command (set `command`). The script can then parse the fields of the command output.

---

Example 14-16. Using set with positional parameters

1 #!/bin/bash 2  3 # script "set-test" 4  5 # Invoke this script with three command line parameters, 6 # for example, "./set-test one two three". 7  8 echo 9 echo "Positional parameters before set \`uname -a\` :" 10 echo "Command-line argument #1 = $1" 11 echo "Command-line argument #2 = $2" 12 echo "Command-line argument #3 = $3" 13  14  15 set `uname -a` # Sets the positional parameters to the output 16  # of the command `uname -a` 17  18 echo $_ # unknown 19 # Flags set in script. 20  21 echo "Positional parameters after set \`uname -a\` :" 22 # $1, $2, $3, etc. reinitialized to result of `uname -a` 23 echo "Field #1 of 'uname -a' = $1" 24 echo "Field #2 of 'uname -a' = $2" 25 echo "Field #3 of 'uname -a' = $3" 26 echo --- 27 echo $_ # --- 28 echo 29  30 exit 0

---

More fun with positional parameters.

---

Example 14-17. Reversing the positional parameters

1 #!/bin/bash 2 # revposparams.sh: Reverse positional parameters. 3 # Script by Dan Jacobson, with stylistic revisions by document author. 4  5  6 set a\ b c d\ e; 7 # ^ ^ Spaces escaped 8 # ^ ^ Spaces not escaped 9 OIFS=$IFS; IFS=:; 10 # ^ Saving old IFS and setting new one. 11  12 echo 13  14 until [ $# -eq 0 ] 15 do # Step through positional parameters. 16  echo "### k0 = "$k"" # Before 17  k=$1:$k; # Append each pos param to loop variable. 18 # ^ 19  echo "### k = "$k"" # After 20  echo 21  shift; 22 done 23  24 set $k # Set new positional parameters. 25 echo - 26 echo $# # Count of positional parameters. 27 echo - 28 echo 29  30 for i # Omitting the "in list" sets the variable -- i -- 31  #+ to the positional parameters. 32 do 33  echo $i # Display new positional parameters. 34 done 35  36 IFS=$OIFS # Restore IFS. 37  38 # Question: 39 # Is it necessary to set an new IFS, internal field separator, 40 #+ in order for this script to work properly? 41 # What happens if you don't? Try it. 42 # And, why use the new IFS -- a colon -- in line 17, 43 #+ to append to the loop variable? 44 # What is the purpose of this? 45  46 exit 0 47  48 $ ./revposparams.sh 49  50 ### k0 = 51 ### k = a b 52  53 ### k0 = a b 54 ### k = c a b 55  56 ### k0 = c a b 57 ### k = d e c a b 58  59 - 60 3 61 - 62  63 d e 64 c 65 a b

---

Invoking set without any options or arguments simply lists all the environmental and other variables that have been initialized.

bash$ set AUTHORCOPY=/home/bozo/posts BASH=/bin/bash BASH_VERSION=$'2.05.8(1)-release' ... XAUTHORITY=/home/bozo/.Xauthority _=/etc/bashrc variable22=abc variable23=xzy

Using set with the -- option explicitly assigns the contents of a variable to the positional parameters. If no variable follows the -- it unsets the positional parameters.

---

Example 14-18. Reassigning the positional parameters

1 #!/bin/bash 2  3 variable="one two three four five" 4  5 set -- $variable 6 # Sets positional parameters to the contents of "$variable". 7  8 first_param=$1 9 second_param=$2 10 shift; shift # Shift past first two positional params. 11 # shift 2 also works. 12 remaining_params="$*" 13  14 echo 15 echo "first parameter = $first_param" # one 16 echo "second parameter = $second_param" # two 17 echo "remaining parameters = $remaining_params" # three four five 18  19 echo; echo 20  21 # Again. 22 set -- $variable 23 first_param=$1 24 second_param=$2 25 echo "first parameter = $first_param" # one 26 echo "second parameter = $second_param" # two 27  28 # ====================================================== 29  30 set -- 31 # Unsets positional parameters if no variable specified. 32  33 first_param=$1 34 second_param=$2 35 echo "first parameter = $first_param" # (null value) 36 echo "second parameter = $second_param" # (null value) 37  38 exit 0

---

See also Example 10-2 and Example 15-52.

unset

The unset command deletes a shell variable, effectively setting it to null. Note that this command does not affect positional parameters.

bash$ unset PATH bash$ echo $PATH bash$

---

Example 14-19. "Unsetting" a variable

1 #!/bin/bash 2 # unset.sh: Unsetting a variable. 3  4 variable=hello # Initialized. 5 echo "variable = $variable" 6  7 unset variable # Unset. 8  # Same effect as: variable= 9 echo "(unset) variable = $variable" # $variable is null. 10  11 if [ -z "$variable" ] # Try a string-length test. 12 then 13  echo "\$variable has zero length." 14 fi 15  16 exit 0

---

export

The export [2] command makes available variables to all child processes of the running script or shell. One important use of the export command is in startup files, to initialize and make accessible environmental variables to subsequent user processes.

Unfortunately, there is no way to export variables back to the parent process, to the process that called or invoked the script or shell.

---

Example 14-20. Using export to pass a variable to an embedded awk script

1 #!/bin/bash 2  3 # Yet another version of the "column totaler" script (col-totaler.sh) 4 #+ that adds up a specified column (of numbers) in the target file. 5 # This uses the environment to pass a script variable to 'awk' . . . 6 #+ and places the awk script in a variable. 7  8  9 ARGS=2 10 E_WRONGARGS=65 11  12 if [ $# -ne "$ARGS" ] # Check for proper no. of command line args. 13 then 14  echo "Usage: `basename $0` filename column-number" 15  exit $E_WRONGARGS 16 fi 17  18 filename=$1 19 column_number=$2 20  21 #===== Same as original script, up to this point =====# 22  23 export column_number 24 # Export column number to environment, so it's available for retrieval. 25  26  27 # ----------------------------------------------- 28 awkscript='{ total += $ENVIRON["column_number"] } 29 END { print total }' 30 # Yes, a variable can hold an awk script. 31 # ----------------------------------------------- 32  33 # Now, run the awk script. 34 awk "$awkscript" "$filename" 35  36 # Thanks, Stephane Chazelas. 37  38 exit 0

---

It is possible to initialize and export variables in the same operation, as in export var1=xxx. However, as Greg Keraunen points out, in certain situations this may have a different effect than setting a variable, then exporting it. bash$ export var=(a b); echo ${var[0]} (a b) bash$ var=(a b); export var; echo ${var[0]} a

declare, typeset

The declare and typeset commands specify and/or restrict properties of variables.

readonly

Same as declare -r, sets a variable as read-only, or, in effect, as a constant. Attempts to change the variable fail with an error message. This is the shell analog of the C language const type qualifier.

getopts

This powerful tool parses command-line arguments passed to the script. This is the Bash analog of the getopt external command and the getopt library function familiar to C programmers. It permits passing and concatenating multiple options [3] and associated arguments to a script (for example scriptname -abc -e /usr/local).

The getopts construct uses two implicit variables. $OPTIND is the argument pointer (OPTion INDex) and $OPTARG (OPTion ARGument) the (optional) argument attached to an option. A colon following the option name in the declaration tags that option as having an associated argument.

A getopts construct usually comes packaged in a while loop, which processes the options and arguments one at a time, then increments the implicit $OPTIND variable to step to the next.

The arguments passed from the command line to the script must be preceded by a minus (-). It is the prefixed - that lets getopts recognize command-line arguments as options. In fact, getopts will not process arguments without the prefixed -, and will terminate option processing at the first argument encountered lacking them. The getopts template differs slightly from the standard while loop, in that it lacks condition brackets. The getopts construct replaces the deprecated getopt external command.

1 while getopts ":abcde:fg" Option 2 # Initial declaration. 3 # a, b, c, d, e, f, and g are the options (flags) expected. 4 # The : after option 'e' shows it will have an argument passed with it. 5 do 6  case $Option in 7  a ) # Do something with variable 'a'. 8  b ) # Do something with variable 'b'. 9  ... 10  e) # Do something with 'e', and also with $OPTARG, 11  # which is the associated argument passed with option 'e'. 12  ... 13  g ) # Do something with variable 'g'. 14  esac 15 done 16 shift $(($OPTIND - 1)) 17 # Move argument pointer to next. 18  19 # All this is not nearly as complicated as it looks <grin>.

---

Example 14-21. Using getopts to read the options/arguments passed to a script

1 #!/bin/bash 2 # Exercising getopts and OPTIND 3 # Script modified 10/09/03 at the suggestion of Bill Gradwohl. 4  5  6 # Here we observe how 'getopts' processes command line arguments to script. 7 # The arguments are parsed as "options" (flags) and associated arguments. 8  9 # Try invoking this script with 10 # 'scriptname -mn' 11 # 'scriptname -oq qOption' (qOption can be some arbitrary string.) 12 # 'scriptname -qXXX -r' 13 # 14 # 'scriptname -qr' - Unexpected result, takes "r" as the argument to option "q" 15 # 'scriptname -q -r' - Unexpected result, same as above 16 # 'scriptname -mnop -mnop' - Unexpected result 17 # (OPTIND is unreliable at stating where an option came from). 18 # 19 # If an option expects an argument ("flag:"), then it will grab 20 #+ whatever is next on the command line. 21  22 NO_ARGS=0 23 E_OPTERROR=65 24  25 if [ $# -eq "$NO_ARGS" ] # Script invoked with no command-line args? 26 then 27  echo "Usage: `basename $0` options (-mnopqrs)" 28  exit $E_OPTERROR # Exit and explain usage, if no argument(s) given. 29 fi 30 # Usage: scriptname -options 31 # Note: dash (-) necessary 32  33  34 while getopts ":mnopq:rs" Option 35 do 36  case $Option in 37  m ) echo "Scenario #1: option -m- [OPTIND=${OPTIND}]";; 38  n | o ) echo "Scenario #2: option -$Option- [OPTIND=${OPTIND}]";; 39  p ) echo "Scenario #3: option -p- [OPTIND=${OPTIND}]";; 40  q ) echo "Scenario #4: option -q-\ 41  with argument \"$OPTARG\" [OPTIND=${OPTIND}]";; 42  # Note that option 'q' must have an associated argument, 43  #+ otherwise it falls through to the default. 44  r | s ) echo "Scenario #5: option -$Option-";; 45  * ) echo "Unimplemented option chosen.";; # DEFAULT 46  esac 47 done 48  49 shift $(($OPTIND - 1)) 50 # Decrements the argument pointer so it points to next argument. 51 # $1 now references the first non option item supplied on the command line 52 #+ if one exists. 53  54 exit 0 55  56 # As Bill Gradwohl states, 57 # "The getopts mechanism allows one to specify: scriptname -mnop -mnop 58 #+ but there is no reliable way to differentiate what came from where 59 #+ by using OPTIND."

---

Script Behavior

source, . (dot command)

This command, when invoked from the command line, executes a script. Within a script, a source file-name loads the file file-name. Sourcing a file (dot-command) imports code into the script, appending to the script (same effect as the #include directive in a C program). The net result is the same as if the "sourced" lines of code were physically present in the body of the script. This is useful in situations when multiple scripts use a common data file or function library.

---

Example 14-22. "Including" a data file

1 #!/bin/bash 2  3 . data-file # Load a data file. 4 # Same effect as "source data-file", but more portable. 5  6 # The file "data-file" must be present in current working directory, 7 #+ since it is referred to by its 'basename'. 8  9 # Now, reference some data from that file. 10  11 echo "variable1 (from data-file) = $variable1" 12 echo "variable3 (from data-file) = $variable3" 13  14 let "sum = $variable2 + $variable4" 15 echo "Sum of variable2 + variable4 (from data-file) = $sum" 16 echo "message1 (from data-file) is \"$message1\"" 17 # Note: escaped quotes 18  19 print_message This is the message-print function in the data-file. 20  21  22 exit 0

File data-file for Example 14-22, above. Must be present in same directory.

1 # This is a data file loaded by a script. 2 # Files of this type may contain variables, functions, etc. 3 # It may be loaded with a 'source' or '.' command by a shell script. 4  5 # Let's initialize some variables. 6  7 variable1=22 8 variable2=474 9 variable3=5 10 variable4=97 11  12 message1="Hello, how are you?" 13 message2="Enough for now. Goodbye." 14  15 print_message () 16 { 17 # Echoes any message passed to it. 18  19  if [ -z "$1" ] 20  then 21  return 1 22  # Error, if argument missing. 23  fi 24  25  echo 26  27  until [ -z "$1" ] 28  do 29  # Step through arguments passed to function. 30  echo -n "$1" 31  # Echo args one at a time, suppressing line feeds. 32  echo -n " " 33  # Insert spaces between words. 34  shift 35  # Next one. 36  done 37  38  echo 39  40  return 0 41 }

---

If the sourced file is itself an executable script, then it will run, then return control to the script that called it. A sourced executable script may use a return for this purpose.

Arguments may be (optionally) passed to the sourced file as positional parameters.

1 source $filename $arg1 arg2

It is even possible for a script to source itself, though this does not seem to have any practical applications.

---

Example 14-23. A (useless) script that sources itself

1 #!/bin/bash 2 # self-source.sh: a script sourcing itself "recursively." 3 # From "Stupid Script Tricks," Volume II. 4  5 MAXPASSCNT=100 # Maximum number of execution passes. 6  7 echo -n "$pass_count " 8 # At first execution pass, this just echoes two blank spaces, 9 #+ since $pass_count still uninitialized. 10  11 let "pass_count += 1" 12 # Assumes the uninitialized variable $pass_count 13 #+ can be incremented the first time around. 14 # This works with Bash and pdksh, but 15 #+ it relies on non-portable (and possibly dangerous) behavior. 16 # Better would be to initialize $pass_count to 0 before incrementing. 17  18 while [ "$pass_count" -le $MAXPASSCNT ] 19 do 20  . $0 # Script "sources" itself, rather than calling itself. 21  # ./$0 (which would be true recursion) doesn't work here. Why? 22 done 23  24 # What occurs here is not actually recursion, 25 #+ since the script effectively "expands" itself, i.e., 26 #+ generates a new section of code 27 #+ with each pass through the 'while' loop', 28 # with each 'source' in line 20. 29 # 30 # Of course, the script interprets each newly 'sourced' "#!" line 31 #+ as a comment, and not as the start of a new script. 32  33 echo 34  35 exit 0 # The net effect is counting from 1 to 100. 36  # Very impressive. 37  38 # Exercise: 39 # -------- 40 # Write a script that uses this trick to actually do something useful.

---

exit

Unconditionally terminates a script. [4] The exit command may optionally take an integer argument, which is returned to the shell as the exit status of the script. It is good practice to end all but the simplest scripts with an exit 0, indicating a successful run.

If a script terminates with an exit lacking an argument, the exit status of the script is the exit status of the last command executed in the script, not counting the exit. This is equivalent to an exit $?.

An exit command may also be used to terminate a subshell.

exec

This shell builtin replaces the current process with a specified command. Normally, when the shell encounters a command, it forks off a child process to actually execute the command. Using the exec builtin, the shell does not fork, and the command exec'ed replaces the shell. When used in a script, therefore, it forces an exit from the script when the exec'ed command terminates. [5]

---

Example 14-24. Effects of exec

1 #!/bin/bash 2  3 exec echo "Exiting \"$0\"." # Exit from script here. 4  5 # ---------------------------------- 6 # The following lines never execute. 7  8 echo "This echo will never echo." 9  10 exit 99 # This script will not exit here. 11  # Check exit value after script terminates 12  #+ with an 'echo $?'. 13  # It will *not* be 99.

---

---

Example 14-25. A script that exec's itself

1 #!/bin/bash 2 # self-exec.sh 3  4 echo 5  6 echo "This line appears ONCE in the script, yet it keeps echoing." 7 echo "The PID of this instance of the script is still $$." 8 # Demonstrates that a subshell is not forked off. 9  10 echo "==================== Hit Ctl-C to exit ====================" 11  12 sleep 1 13  14 exec $0 # Spawns another instance of this same script 15  #+ that replaces the previous one. 16  17 echo "This line will never echo!" # Why not? 18  19 exit 99 # Will not exit here! 20  # Exit code will not be 99!

---

An exec also serves to reassign file descriptors. For example, exec <zzz-file replaces stdin with the file zzz-file.

The -exec option to find is not the same as the exec shell builtin.

shopt

This command permits changing shell options on the fly (see Example 24-1 and Example 24-2). It often appears in the Bash startup files, but also has its uses in scripts. Needs version 2 or later of Bash.

1 shopt -s cdspell 2 # Allows minor misspelling of directory names with 'cd' 3  4 cd /hpme # Oops! Mistyped '/home'. 5 pwd # /home 6  # The shell corrected the misspelling.

caller

Putting a caller command inside a function echoes to stdout information about the caller of that function.

1 #!/bin/bash 2  3 function1 () 4 { 5  # Inside function1 (). 6  caller 0 # Tell me about it. 7 } 8  9 function1 # Line 9 of script. 10  11 # 9 main test.sh 12 # ^ Line number that the function was called from. 13 # ^^^^ Invoked from "main" part of script. 14 # ^^^^^^^ Name of calling script. 15  16 caller 0 # Has no effect because it's not inside a function.

A caller command can also return caller information from a script sourced within another script. Analogous to a function, this is a "subroutine call."

You may find this command useful in debugging.

Commands

true

A command that returns a successful (zero) exit status, but does nothing else.

bash$ true bash$ echo $? 0

1 # Endless loop 2 while true # alias for ":" 3 do 4  operation-1 5  operation-2 6  ... 7  operation-n 8  # Need a way to break out of loop or script will hang. 9 done

false

A command that returns an unsuccessful exit status, but does nothing else.

bash$ false bash$ echo $? 1

1 # Testing "false" 2 if false 3 then 4  echo "false evaluates \"true\"" 5 else 6  echo "false evaluates \"false\"" 7 fi 8 # false evaluates "false" 9  10  11 # Looping while "false" (null loop) 12 while false 13 do 14  # The following code will not execute. 15  operation-1 16  operation-2 17  ... 18  operation-n 19  # Nothing happens! 20 done

type [cmd]

Similar to the which external command, type cmd identifies "cmd." Unlike which, type is a Bash builtin. The useful -a option to type identifies keywords and builtins, and also locates system commands with identical names.

bash$ type '[' [ is a shell builtin bash$ type -a '[' [ is a shell builtin [ is /usr/bin/[ bash$ type type type is a shell builtin

hash [cmds]

Record the path name of specified commands -- in the shell hash table [6] -- so the shell or script will not need to search the $PATH on subsequent calls to those commands. When hash is called with no arguments, it simply lists the commands that have been hashed. The -r option resets the hash table.

bind

The bind builtin displays or modifies readline [7] key bindings.

help

Gets a short usage summary of a shell builtin. This is the counterpart to whatis, but for builtins.

bash$ help exit exit: exit [n] Exit the shell with a status of N. If N is omitted, the exit status is that of the last command executed.