Chapter 14. Command Substitution

Command substitution reassigns the output of a command [1] or even multiple commands; it literally plugs the command output into another context.

The classic form of command substitution uses backquotes (`...`). Commands within backquotes (backticks) generate command line text.
script_name=`basename $0`
echo "The name of this script is $script_name."

The output of commands can be used as arguments to another command, to set a variable, and even for generating the argument list in a for loop.

rm `cat filename`   # "filename" contains a list of files to delete.
#
# S. C. points out that "arg list too long" error might result.
# Better is              xargs rm -- < filename 
# ( -- covers those cases where "filename" begins with a "-" )

textfile_listing=`ls *.txt`
# Variable contains names of all *.txt files in current working directory.
echo $textfile_listing

textfile_listing2=$(ls *.txt)   # The alternative form of command substitution.
echo $textfile_listing
# Same result.

# A possible problem with putting a list of files into a single string
# is that a newline may creep in.
#
# A safer way to assign a list of files to a parameter is with an array.
#      shopt -s nullglob    # If no match, filename expands to nothing.
#      textfile_listing=( *.txt )
#
# Thanks, S.C.

Caution

Command substitution may result in word splitting.
COMMAND `echo a b`     # 2 args: a and b

COMMAND "`echo a b`"   # 1 arg: "a b"

COMMAND `echo`         # no arg

COMMAND "`echo`"       # one empty arg


# Thanks, S.C.

Caution

Word splitting resulting from command substitution may remove trailing newlines characters from the output of the reassigned command(s). This can cause unpleasant surprises.
dir_listing=`ls -l`
echo $dirlisting

# Expecting a nicely ordered directory listing, such as:
# -rw-rw-r--    1 bozo       30 May 13 17:15 1.txt
# -rw-rw-r--    1 bozo       51 May 15 20:57 t2.sh
# -rwxr-xr-x    1 bozo      217 Mar  5 21:13 wi.sh

# However, what you get is:
# total 3 -rw-rw-r-- 1 bozo bozo 30 May 13 17:15 1.txt -rw-rw-r-- 1 bozo
# bozo 51 May 15 20:57 t2.sh -rwxr-xr-x 1 bozo bozo 217 Mar 5 21:13 wi.sh

# The newlines disappeared.

Even when there is no word splitting, command substitution can remove trailing newlines.
# cd "`pwd`"  # This should always work.
# However...

mkdir 'dir with trailing newline
'

cd 'dir with trailing newline
'

cd "`pwd`"  # Error message:
# bash: cd: /tmp/file with trailing newline: No such file or directory

cd "$PWD"   # Works fine.





old_tty_setting=$(stty -g)   # Save old terminal setting.
echo "Hit a key "
stty -icanon -echo           # Disable "canonical" mode for terminal.
                             # Also, disable *local* echo.
key=$(dd bs=1 count=1 2> /dev/null)   # Using 'dd' to get a keypress.
stty "$old_tty_setting"      # Restore old setting. 
echo "You hit ${#key} key."  # ${#variable} = number of characters in $variable
#
# Hit any key except RETURN, and the output is "You hit 1 key."
# Hit RETURN, and it's "You hit 0 key."
# The newline gets eaten in the command substitution.

Thanks, S.C.

Tip

Command substitution even permits setting a variable to the contents of a file, using either redirection or the cat command.
variable1=`<file1`      # Set "variable1" to contents of "file1".
variable2=`cat file2`   # Set "variable2" to contents of "file2".

#  Be aware that the variables may contain embedded whitespace,
#+ or even (horrors), control characters.

Note

The $(COMMAND) form has superseded backticks for command substitution.
output=$(sed -n /"$1"/p $file)
# From "grp.sh"	example.

Examples of command substitution in shell scripts:

  1. Example 10-7

  2. Example 10-24

  3. Example 9-22

  4. Example 12-2

  5. Example 12-15

  6. Example 12-12

  7. Example 12-32

  8. Example 10-12

  9. Example 10-9

  10. Example 12-24

  11. Example 16-5

  12. Example A-12

  13. Example 28-1

  14. Example 12-28

  15. Example 12-29

  16. Example 12-30

Notes

[1]

For purposes of command substitution, a command may be an external system command, an internal scripting builtin, or even a script function.