Comments may also occur following the end of a command.
echo "A comment will follow." # Comment here.
# ^ Note whitespace before #
Comments may also follow whitespace at the beginning
of a line.
# A tab precedes this comment.
A command may not follow a comment on the
same line. There is no method of terminating the comment,
in order for "live code" to begin on the same
line. Use a new line for the next command.
echo "The # here does not begin a comment."
echo 'The # here does not begin a comment.'
echo The \# here does not begin a comment.
echo The # here begins a comment.
echo ${PATH#*:} # Parameter substitution, not a comment.
echo $(( 2#101011 )) # Base conversion, not a comment.
# Thanks, S.C.
Command separator [semicolon]. Permits putting two or more commands on the same
line.
echo hello; echo there
if [ -x "$filename" ]; then # Note that "if" and "then" need separation.
# Why?
echo "File $filename exists."; cp $filename $filename.bak
else
echo "File $filename not found."; touch $filename
fi; echo "File test complete."
partial
quoting [double quote]. "STRING" preserves (from
interpretation) most of the special characters within
STRING. See also Chapter 5.
'
full
quoting [single quote]. 'STRING' preserves all special
characters within STRING. This is a
stronger form of quoting than using ".
See also Chapter 5.
,
comma
operator. The comma operator links together a
series of arithmetic operations. All are evaluated, but only
the last one is returned.
let "t2 = ((a = 9, 15 / 3))" # Set "a = 9" and "t2 = 15 / 3"
\
escape [backslash]. A quoting mechanism for single characters.
\X"escapes" the character
X. This has the effect of
"quoting"X, equivalent
to 'X'. The \ may
be used to quote " and ',
so they are expressed literally.
See Chapter 5 for an in-depth explanation
of escaped characters.
/
Filename path separator [forward slash]. Separates the components of a filename (as in
/home/bozo/projects/Makefile).
command substitution. The `command` construct makes
available the output of command
for assignment to a variable. This is also known as
backquotes or
backticks.
:
null command [colon]. This is the shell equivalent of a
"NOP" (no op, a
do-nothing operation). It may be considered a synonym for
the shell builtin true. The
":" command is itself a
Bash builtin, and its
exit status is
"true" (0).
:
echo $? # 0
Endless loop:
while :
do
operation-1
operation-2
...
operation-n
done
# Same as:
# while true
# do
# ...
# done
Placeholder in if/then test:
if condition
then : # Do nothing and branch ahead
else
take-some-action
fi
In combination with the >redirection operator,
truncates a file to zero length, without changing its
permissions. If the file did not previously exist,
creates it.
: > data.xxx # File "data.xxx" now empty.
# Same effect as cat /dev/null >data.xxx
# However, this does not fork a new process, since ":" is a builtin.
In combination with the >>
redirection operator, has no effect on a pre-existing
target file (: >> target_file).
If the file did not previously exist, creates it.
This applies to regular files, not pipes,
symlinks, and certain special files.
May be used to begin a comment line, although this is not
recommended. Using # for a comment turns
off error checking for the remainder of that line, so
almost anything may appear in a comment. However,
this is not the case with
:.
: This is a comment that generates an error, ( if [ $x -eq 3] ).
The ":" also serves as a field
separator, in /etc/passwd, and in the $PATH variable.
reverse (or negate) the sense of
a test or exit status [bang]. The ! operator inverts the exit status
of the command to which it is applied (see
Example 6-2). It also inverts
the meaning of a test operator. This can, for
example, change the sense of "equal"
( =
) to "not-equal" ( != ). The
! operator is a Bash keyword.
In yet another context, from the command
line, the ! invokes the
Bash history mechanism (see Appendix J). Note that within a script,
the history mechanism is disabled.
*
wild card [asterisk]. The * character serves as a "wild
card" for filename expansion in
globbing. By itself,
it matches every filename in a given directory.
a=123
( a=321; )
echo "a = $a" # a = 123
# "a" within parentheses acts like a local variable.
array initialization.
Array=(element1 element2 element3)
{xxx,yyy,zzz,...}
Brace expansion.
cat {file1,file2,file3} > combined_file
# Concatenates the files file1, file2, and file3 into combined_file.
cp file22.{txt,backup}
# Copies "file22.txt" to "file22.backup"
A command may act upon a comma-separated list of file specs within
braces.
[1]
Filename expansion (globbing)
applies to the file specs between the braces.
No spaces allowed within the braces
unless the spaces are quoted or escaped.
echo {file1,file2}\ :{\ A," B",' C'}
file1 : A file1 : B file1 : C file2 : A file2 : B file2 : C
{}
Block of code [curly brackets]. Also referred to as an "inline group",
this construct, in effect, creates an anonymous
function. However, unlike a function, the variables
in a code block remain visible to the remainder of the
script.
bash$ { local a;
a=123; }bash: local: can only be used in a
function
a=123
{ a=321; }
echo "a = $a" # a = 321 (value inside code block)
# Thanks, S.C.
The code block enclosed in braces may have I/O redirected to and from
it.
Example 3-1. Code blocks and I/O redirection
#!/bin/bash
# Reading lines in /etc/fstab.
File=/etc/fstab
{
read line1
read line2
} < $File
echo "First line in $File is:"
echo "$line1"
echo
echo "Second line in $File is:"
echo "$line2"
exit 0
# Now, how do you parse the separate fields of each line?
# Hint: use awk.
Example 3-2. Saving the results of a code block to a file
#!/bin/bash
# rpm-check.sh
# Queries an rpm file for description, listing, and whether it can be installed.
# Saves output to a file.
#
# This script illustrates using a code block.
SUCCESS=0
E_NOARGS=65
if [ -z "$1" ]
then
echo "Usage: `basename $0` rpm-file"
exit $E_NOARGS
fi
{
echo
echo "Archive Description:"
rpm -qpi $1 # Query description.
echo
echo "Archive Listing:"
rpm -qpl $1 # Query listing.
echo
rpm -i --test $1 # Query whether rpm file can be installed.
if [ "$?" -eq $SUCCESS ]
then
echo "$1 can be installed."
else
echo "$1 cannot be installed."
fi
echo
} > "$1.test" # Redirects output of everything in block to file.
echo "Results of rpm test in file $1.test"
# See rpm man page for explanation of options.
exit 0
Unlike a command group within (parentheses),
as above, a code block enclosed by {braces} will
not normally launch a subshell.
[2]
{} \;
pathname. Mostly used in find
constructs. This is not a shell
builtin.
The ";" ends
the -exec option of a
find command sequence. It needs
to be escaped to protect it from interpretation by the
shell.
[ ]
test.
Test expression between [
]. Note that [ is part of
the shell builtin test (and a synonym
for it), not a link to the external
command /usr/bin/test.
veg1=carrots
veg2=tomatoes
if [[ "$veg1" < "$veg2" ]]
then
echo "Although $veg1 precede $veg2 in the dictionary,"
echo "this implies nothing about my culinary preferences."
else
echo "What kind of dictionary are you using, anyhow?"
fi
pipe. Passes the output of previous command to the input
of the next one, or to the shell. This is a method of
chaining commands together.
echo ls -l | sh
# Passes the output of "echo ls -l" to the shell,
#+ with the same result as a simple "ls -l".
cat *.lst | sort | uniq
# Merges and sorts all ".lst" files, then deletes duplicate lines.
A pipe, as a classic method of interprocess
communication, sends the stdout
of one process to the stdin
of another. In a typical case, a command,
such as cat or echo, pipes a stream of data to a
"filter" (a command that transforms its input)
for processing.
cat $filename1 $filename2 | grep $search_word
The output of a command or commands
may be piped to a script.
#!/bin/bash
# uppercase.sh : Changes input to uppercase.
tr 'a-z' 'A-Z'
# Letter ranges must be quoted
#+ to prevent filename generation from single-letter filenames.
exit 0
Now, let us pipe the output of ls -l to this
script.
The stdout of each process in
a pipe must be read as the stdin
of the next. If this is not the case, the data stream
will block, and the pipe will not
behave as expected.
cat file1 file2 | ls -l | sort
# The output from "cat file1 file2" disappears.
A pipe runs as a child
process, and therefore cannot alter script
variables.
If one of the commands in the pipe
aborts, this prematurely terminates execution of the
pipe. Called a broken pipe, this
condition sends a SIGPIPEsignal.
>|
force redirection (even if
the noclobber option
is set). This will forcibly overwrite an existing file.
||
OR logical operator. In a test
construct, the || operator causes
a return of 0 (success) if
either of the linked test conditions
is true.
&
Run job in background. A command followed by an &
will run in the background.
bash$ sleep 10 &[1] 850[1]+ Done sleep 10
Within a script, commands and even loops may run in the
background.
Example 3-3. Running a loop in the background
#!/bin/bash
# background-loop.sh
for i in 1 2 3 4 5 6 7 8 9 10 # First loop.
do
echo -n "$i "
done & # Run this loop in background.
# Will sometimes execute after second loop.
echo # This 'echo' sometimes will not display.
for i in 11 12 13 14 15 16 17 18 19 20 # Second loop.
do
echo -n "$i "
done
echo # This 'echo' sometimes will not display.
# ======================================================
# The expected output from the script:
# 1 2 3 4 5 6 7 8 9 10
# 11 12 13 14 15 16 17 18 19 20
# Sometimes, though, you get:
# 11 12 13 14 15 16 17 18 19 20
# 1 2 3 4 5 6 7 8 9 10 bozo $
# (The second 'echo' doesn't execute. Why?)
# Occasionally also:
# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# (The first 'echo' doesn't execute. Why?)
# Very rarely something like:
# 11 12 13 1 2 3 4 5 6 7 8 9 10 14 15 16 17 18 19 20
# The foreground loop preempts the background one.
exit 0
# Nasimuddin Ansari suggests adding sleep 1
#+ after the echo -n "$i" in lines 6 and 14,
#+ for some real fun.
A command run in the background within a
script may cause the script to hang, waiting
for a keystroke. Fortunately, there is a remedy for this.
&&
AND logical
operator. In a test
construct, the && operator causes
a return of 0 (success) only if
both the linked test conditions
are true.
-
option, prefix. Option flag for a command or filter. Prefix for
an operator.
COMMAND -[Option1][Option2][...]
ls -al
sort -dfu $filename
set -- $variable
if [ $file1 -ot $file2 ]
then
echo "File $file1 is older than $file2."
fi
if [ "$a" -eq "$b" ]
then
echo "$a is equal to $b."
fi
if [ "$c" -eq 24 -a "$d" -eq 47 ]
then
echo "$c equals 24 and $d equals 47."
fi
-
redirection from/to stdin or stdout [dash].
(cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)
# Move entire file tree from one directory to another
# [courtesy Alan Cox <[email protected]>, with a minor change]
# 1) cd /source/directory Source directory, where the files to be moved are.
# 2) && "And-list": if the 'cd' operation successful, then execute the next command.
# 3) tar cf - . The 'c' option 'tar' archiving command creates a new archive,
# the 'f' (file) option, followed by '-' designates the target file as stdout,
# and do it in current directory tree ('.').
# 4) | Piped to...
# 5) ( ... ) a subshell
# 6) cd /dest/directory Change to the destination directory.
# 7) && "And-list", as above
# 8) tar xpvf - Unarchive ('x'), preserve ownership and file permissions ('p'),
# and send verbose messages to stdout ('v'),
# reading data from stdin ('f' followed by '-').
#
# Note that 'x' is a command, and 'p', 'v', 'f' are options.
# Whew!
# More elegant than, but equivalent to:
# cd source/directory
# tar cf - . | (cd ../dest/directory; tar xpvf -)
#
# Also having same effect:
# cp -a /source/directory/* /dest/directory
# Or:
# cp -a /source/directory/* /source/directory/.[^.]* /dest/directory
# If there are hidden files in /source/directory.
bunzip2 linux-2.6.13.tar.bz2 | tar xvf -
# --uncompress tar file-- | --then pass it to "tar"--
# If "tar" has not been patched to handle "bunzip2",
# this needs to be done in two discrete steps, using a pipe.
# The purpose of the exercise is to unarchive "bzipped" kernel source.
Note that in this context the "-" is not
itself a Bash operator, but rather an option recognized by
certain UNIX utilities that write to
stdout, such as tar,
cat, etc.
bash$ echo "whatever" | cat -whatever
Where a filename is expected,
- redirects output to
stdout (sometimes seen with
tar cf), or accepts input from
stdin, rather than from a file. This
is a method of using a file-oriented utility as a filter
in a pipe.
Example 3-4. Backup of all files changed in last day
#!/bin/bash
# Backs up all files in current directory modified within last 24 hours
#+ in a "tarball" (tarred and gzipped file).
BACKUPFILE=backup-$(date +%m-%d-%Y)
# Embeds date in backup filename.
# Thanks, Joshua Tschida, for the idea.
archive=${1:-$BACKUPFILE}
# If no backup-archive filename specified on command line,
#+ it will default to "backup-MM-DD-YYYY.tar.gz."
tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
gzip $archive.tar
echo "Directory $PWD backed up in archive file \"$archive.tar.gz\"."
# Stephane Chazelas points out that the above code will fail
#+ if there are too many files found
#+ or if any filenames contain blank characters.
# He suggests the following alternatives:
# -------------------------------------------------------------------
# find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"
# using the GNU version of "find".
# find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
# portable to other UNIX flavors, but much slower.
# -------------------------------------------------------------------
exit 0
Filenames beginning with
"-" may cause problems when coupled with the
"-" redirection operator. A script should
check for this and add an appropriate prefix to such
filenames, for example ./-FILENAME,
$PWD/-FILENAME, or
$PATHNAME/-FILENAME.
If the value of a variable begins with a
-, this may likewise create
problems.
var="-n"
echo $var
# Has the effect of "echo -n", and outputs nothing.
-
previous working directory. A cd - command changes to the
previous working directory. This uses the
$OLDPWDenvironmental variable.
Do not confuse the "-" used in this
sense with the "-" redirection
operator just discussed. The interpretation of the
"-" depends on the context in which it
appears.
home directory [tilde]. This corresponds to the $HOME internal variable.
~bozo is bozo's home directory,
and ls ~bozo lists the contents of it.
~/ is the current user's home directory,
and ls ~/ lists the contents of it.
"EOF" (end of file). This also
terminates input from stdin.
When typing text on the console or in an
xterm window,
Ctl-D erases the character under the
cursor. When there are no characters present,
Ctl-D logs out of the session, as
expected. In an xterm window, this has the effect of closing
the window.
Ctl-G
"BEL" (beep). On some old-time teletype
terminals, this would actually ring a bell.
Ctl-H
"Rubout" (destructive backspace). Erases
characters the cursor backs over while backspacing.
#!/bin/bash
# Embedding Ctl-H in a string.
a="^H^H" # Two Ctl-H's (backspaces).
echo "abcdef" # abcdef
echo -n "abcdef$a " # abcd f
# Space at end ^ ^ Backspaces twice.
echo -n "abcdef$a" # abcdef
# No space at end Doesn't backspace (why?).
# Results may not be quite as expected.
echo; echo
Ctl-I
Horizontal tab.
Ctl-J
Newline (line feed).
Ctl-K
Vertical tab.
When typing text on the console or in an
xterm window,
Ctl-K erases from the character
under the cursor to end of line.
Ctl-L
Formfeed (clear the terminal screen). This has
the same effect as the clear command.
Ctl-M
Carriage return.
#!/bin/bash
# Thank you, Lee Maschmeyer, for this example.
read -n 1 -s -p $'Control-M leaves cursor at beginning of this line. Press Enter. \x0d'
# Of course, '0d' is the hex equivalent of Control-M.
echo >&2 # The '-s' makes anything typed silent,
#+ so it is necessary to go to new line explicitly.
read -n 1 -s -p $'Control-J leaves cursor on next line. \x0a'
echo >&2 # Control-J is linefeed.
###
read -n 1 -s -p $'And Control-K\x0bgoes straight down.'
echo >&2 # Control-K is vertical tab.
# A better example of the effect of a vertical tab is:
var=$'\x0aThis is the bottom line\x0bThis is the top line\x0a'
echo "$var"
# This works the same way as the above example. However:
echo "$var" | col
# This causes the right end of the line to be higher than the left end.
# It also explains why we started and ended with a line feed --
#+ to avoid a garbled screen.
# As Lee Maschmeyer explains:
# --------------------------
# In the [first vertical tab example] . . . the vertical tab
#+ makes the printing go straight down without a carriage return.
# This is true only on devices, such as the Linux console,
#+ that can't go "backward."
# The real purpose of VT is to go straight UP, not down.
# It can be used to print superscripts on a printer.
# The col utility can be used to emulate the proper behavior of VT.
exit 0
Ctl-Q
Resume (XON).
This resumes stdin in a terminal.
Ctl-S
Suspend (XOFF).
This freezes stdin in a terminal.
(Use Ctl-Q to restore input.)
Ctl-U
Erase a line of input, from the cursor backward to
beginning of line. In some settings,
Ctl-U erases the entire
line of input, regardless of cursor
position.
Ctl-V
When inputting text, Ctl-V
permits inserting control characters. For example, the
following two are equivalent:
echo -e '\x0a'
echo <Ctl-V><Ctl-J>
Ctl-V is primarily useful from
within a text editor.
Ctl-W
When typing text on the console or in an xterm window,
Ctl-W erases from the character
under the cursor backwards to the first instance of
whitespace. In some settings, Ctl-W
erases backwards to first non-alphanumeric character.
Ctl-Z
Pause a foreground job.
Whitespace
functions as a separator, separating commands or variables. Whitespace consists of either
spaces,
tabs, blank
lines, or any combination thereof.
[3]
In some contexts, such as variable
assignment, whitespace is not permitted, and
results in a syntax error.
Blank lines have no effect on the action of a script,
and are therefore useful for visually separating functional
sections.
$IFS, the special variable
separating fields of input to certain commands, defaults
to whitespace.
To preserve whitespace within a string or in a variable,
use quoting.
Exception: a code block in braces as
part of a pipe may run as a
subshell.
ls | { read firstline; read secondline; }
# Error. The code block in braces runs as a subshell,
#+ so the output of "ls" cannot be passed to variables within the block.
echo "First line is $firstline; second line is $secondline" # Will not work.
# Thanks, S.C.
