Advanced Bash-Scripting Guide: An in-depth exploration of the art of shell scripting
Prev

Index

This index / glossary / quick-reference lists many of the important topics covered in the text. Terms are arranged in approximate ASCII sorting order, reshuffled as necessary for enhanced clarity.

Note that commands are indexed in Part 4.

* * *

^ (caret) Beginning-of-line, in a Regular Expression

~ Tilde

~ home directory, corresponds to $HOME
~/ Current user's home directory
~+ Current working directory
~- Previous working directory

= Equals sign

= Variable assignment operator
= String comparison operator
== String comparison operator
=~ Regular Expression match operator
Example script

< Left angle bracket

Is-less-than
String comparison
Integer comparison within double parentheses
Redirection
< stdin
<< Here document
<<< Here string
<> Opening a file for both reading and writing

> Right angle bracket

Is-greater-than
String comparison
Integer comparison, within double parentheses
Redirection
> Redirect stdout to a file
>> Redirect stdout to a file, but append
i>&j Redirect file descriptor i to file descriptor j
>&j Redirect stdout to file descriptor j
>&2 Redirect stdout of a command to stderr
2>&1 Redirect stderr to stdout
&> Redirect both stdout and stderr of a command to a file
:> file Truncate file to zero length

| Pipe, a device for passing the output of a command to another command or to the shell

|| Logical OR test operator

- (dash)

Prefix to default parameter, in parameter substitution
Prefix to option flag
Indicating redirection from stdin or stdout
-- (double-dash)
Prefix to long command options
C-style variable decrement within double parentheses

; (semicolon)

As command separator
\; Escaped semicolon, terminates a find command
;; Double-semicolon, terminator in a case option
Required when ...
do keyword is on the first line of loop
terminating curly-bracketed code block

: Colon, null command, equivalent to the true Bash builtin

:> file Truncate file to zero length

! Negation operator, inverts exit status of a test or command

!= not-equal-to String comparison operator

? (question mark)

// Double forward slash, behavior of cd command toward

. (dot / period)

. Load a file (into a script), equivalent to source command
. Match single character, in a Regular Expression
. Current working directory
./ Current working directory
.. Parent directory

' ... ' (single quotes) strong quoting

" ... " (double quotes) weak quoting

() Parentheses

( ... ) Command group; starts a subshell
( ... ) Enclose group of Extended Regular Expressions
>( ... )
<( ... ) Process substitution
... ) Terminates test-condition in case construct
(( ... )) Double parentheses, in arithmetic expansion

[ Left bracket, test construct

[ ]Brackets

Array element
Enclose character set to match in a Regular Expression
Test construct

[[ ... ]] Double brackets, extended test construct

$ Anchor, in a Regular Expression

$ Prefix to a variable name

$( ... ) Command substitution, setting a variable with output of a command, using parentheses notation

` ... ` Command substitution, using backquotes notation

${ ... } Variable manipulation / evaluation

${var} Value of a variable
${#var} Length of a variable
${#@}
${#*} Number of positional parameters
${parameter?err_msg} Parameter-unset message
${parameter-default}
${parameter:-default}
${parameter=default}
${parameter:=default} Set default parameter
${parameter+alt_value}
${parameter:+alt_value}
Alternate value of parameter, if set
${!var}
Indirect referencing of a variable, new notation
${!#}
Final positional parameter. (This is an indirect reference to $#.)
${!varprefix*}
${!varprefix@}
Match names of all previously declared variables beginning with varprefix
${string:position}
${string:position:length} Substring extraction
${var#Pattern}
${var##Pattern} Substring removal
${var%Pattern}
${var%%Pattern} Substring removal
${string/substring/replacement}
${string//substring/replacement}
${string/#substring/replacement}
${string/%substring/replacement} Substring replacement

\ Escape the character following

\< ... \> Angle brackets, escaped, word boundary in a Regular Expression
\{ N \} "Curly" brackets, escaped, number of character sets to match in an Extended RE
\; Semicolon, escaped, terminates a find command
\$$ Indirect reverencing of a variable, old-style notation
Escaping a newline, to write a multi-line command

&> Redirect both stdout and stderr of a command to a file
>&j Redirect stdout to file descriptor j
>&2 Redirect stdout of a command to stderr
i>&j Redirect file descriptor i to file descriptor j
2>&1 Redirect stderr to stdout
Closing file descriptors
n<&- Close input file descriptor n
0<&-, <&- Close stdin
n>&- Close output file descriptor n
1>&-, >&- Close stdout
&& Logical AND test operator
Command & Run job in background

# Hashmark, special symbol beginning a script comment

#! Sha-bang, special string starting a shell script

* Asterisk

Wild card, in globbing
Any number of characters in a Regular Expression
** Exponentiation, arithmetic operator

% Percent sign

Modulo, division-remainder arithmetic operation
Substring removal (pattern matching) operator

+ Plus sign

Character match, in an extended Regular Expression
Prefix to alternate parameter, in parameter substitution
++ C-style variable increment, within double parentheses

* * *

Shell Variables

$_ Last argument to previous command

$- Flags passed to script, using set

$! Process ID of last background job

$? Exit status of a command

$@ All the positional parameters, as separate words

$* All the positional parameters, as a single word

$$ Process ID of the script

$# Number of arguments passed to a function, or to the script itself

$0 Filename of the script

$1 First argument passed to script

$9 Ninth argument passed to script

Table of shell variables

* * * * * *

-a Logical AND compound comparison test

Address database, script example

Advanced Bash Scripting Guide, where to download

Alias

Removing an alias, using unalias

Anagramming

And list

To supply default command-line argument

And logical operator &&

Angle brackets, escaped, \< . . . \> word boundary in a Regular Expression

Anonymous here document, using :

Archiving

Arithmetic expansion

variations of

Arithmetic operators

combination operators, C-style
+= -= *= /= %=
In certain contexts, += can also function as a string concatenation operator.

Arrays

Bracket notation
Concatenating, example script
Copying
Declaring
declare -a array_name
Embedded arrays
Empty arrays, empty elements, example script
Indirect references
Initialization
array=( element1 element2 ... elementN)
Example script
Using command substitution
Loading a file into an array
Multidimensional, simulating
Nesting and embedding
Notation and usage
Number of elements in
${#array_name[@]}
${#array_name[*]}
Operations
Passing an array to a function
As return value from a function
Special properties, example script
String operations, example script
unset deletes array elements

Arrow keys, detecting

ASCII table

awk field-oriented text processing language

rand(), random function
String manipulation
Using export to pass a variable to an embedded awk script

* * *

Backquotes, used in command substitution

Base conversion, example script

Bash

.bashrc

$BASH_SUBSHELL

Basic commands, external

Batch files, DOS

Batch processing

bc, calculator utility

In a here document
Template for calculating a script variable

Bibliography

Bison utility

Bitwise operators

Block devices, testing for

Blocks of code

Redirection
Script example: redirecting output of a a code block

Brace expansion

Extended, {a..z}

Brackets, [ ]

Array element
Enclose character set to match in a Regular Expression
Test construct

Brackets, curly, {}, used in

break loop control command

Parameter (optional)

Builtins in Bash

Do not fork a subprocess

* * *

case construct

Command-line parameters, handling
Globbing, filtering strings with

cat, concatentate file(s)

Character devices, testing for

Child processes

Colon, : , equivalent to the true Bash builtin

Colorizing scripts

Table of color escape sequences
Template, colored text on colored background

Comma operator, linking commands or operations

Command-line options

Command substitution

Comment headers, special purpose

Commenting out blocks of code

Using an anonymous here document
Using an if-then construct

Communications and hosts

Compound comparison operators

Compression utilities

continue loop control command

Control characters

Control-C, break
Control-D, terminate / log out / erase
Control-G, BEL (beep)
Control-H, rubout
Control-J, newline
Control-M, carriage return

cron, scheduling daemon

C-style syntax , for handling variables

Crossword puzzle solver

Curly brackets {}

* * *

Daemons, in UNIX-type OS

date

dc, calculator utility

dd, data duplicator command

Debugging scripts

Decimal number, Bash interprets numbers as

declare builtin

options

Default parameters

/dev directory

/dev/null pseudo-device file
/dev/urandom pseudo-device file, generating pseudorandom numbers with
/dev/zero, pseudo-device file

dialog, utility for generating dialog boxes in a script

$DIRSTACK directory stack

Disabled commands, in restricted shells

do keyword, begins execution of commands within a loop

done keyword, terminates a loop

DOS batch files, converting to shell scripts

DOS commands, UNIX equivalents of (table)

dot files, "hidden" setup and configuration files

Double brackets [[ ... ]] test construct

and evaluation of octal/hex constants

Double quotes " ... " weak quoting

Double-spacing a text file, using sed

* * *

-e File exists test

echo

Feeding commands down a pipe
Setting a variable using command substitution
/bin/echo, external echo command

elif, Contraction of else and if

else

esac, keyword terminating case construct

Environmental variables

-eq , is-equal-to integer comparison test

Eratosthenes, Sieve of, algorithm for generating prime numbers

Escaped characters, special meanings of

$EUID, Effective user ID

eval, Combine and evaluate expression(s), with variable expansion

Evaluation of octal/hex constants within [[ ... ]]

exec command, using in redirection

Exercises

Exit and Exit status

exit command
Exit status (exit code, return status of a command)
Table, Exit codes with special meanings
Out of range
Specified by a function return
Successful, 0
/usr/include/sysexits.h, system file listing C/C++ standard exit codes

Export, to make available variables to child processes

Passing a variable to an embedded awk script

expr, Expression evaluator

Extended Regular Expressions

? (question mark) Match zero / one characters
( ... ) Group of expressions
\{ N \} "Curly" brackets, escaped, number of character sets to match
+ Character match

* * *

factor, decomposes an integer into its prime factors

Application: Generating prime numbers

false, returns unsuccessful (1) exit status

Files / Archiving

File descriptors

Closing
n<&- Close input file descriptor n
0<&-, <&- Close stdin
n>&- Close output file descriptor n
1>&-, >&- Close stdout
File handles in C, similarity to

find

{} Curly brackets
\; Escaped semicolon

Filter

Floating point numbers, Bash does not recognize

fold, a filter to wrap lines of text

Forking a child process

for loops

Functions

Arguments passed referred to by position
Capturing the return value of a function using echo
Definition must precede first call to function
Exit status
Local variables
and recursion
Passing an array to a function
Passing pointers to a function
Recursion
Redirecting stdin of a function
return
Multiple return values from a function, example script
Returning an array from a function
return range limits, workarounds
shift arguments passed to a function

* * *

Games and amusements

getopt, external command for parsing script command-line arguments

Emulated in a script

getopts, Bash builtin for parsing script command-line arguments

$OPTIND / $OPTARG

Global variable

Globbing, filename expansion

-ge , greater-than or equal integer comparison test

-gt , greater-than integer comparison test

groff, text markup and formatting language

$GROUPS, Groups user belongs to

gzip, compression utility

* * *

Hashing, creating lookup keys in a table

Example script

head, echo to stdout lines at the beginning of a text file

help, gives usage summary of a Bash builtin

Here documents

Anonymous here documents, using :
Commenting out blocks of code
Self-documenting scripts
bc in a here document
cat scripts
Command substitution
ex scripts
Function, supplying input to
Here strings
Prepending text
Using read
Limit string
Closing limit string may not be indented
Dash option to limit string, <<-LimitString
Literal text output, for generating program code
Parameter substitution
Disabling parameter substitution
Passing parameters
Temporary files
Using vi non-interactively

History commands

$HOME, user's home directory

Homework assignment solver

$HOSTNAME, system host name

* * *

$Id parameter, in rcs (Revision Control System)

if [ condition ]; then ... test construct

if-grep, if and grep in combination
Fixup for if-grep test

$IFS, Internal field separator variable

Defaults to whitespace

Integer comparison operators

in, keyword preceding [list] in a for loop

Initialization table, /etc/inittab

Inline group, i.e., code block

Interactive script, test for

I/O redirection

Indirect referencing of variables

New notation, introduced in version 2 of Bash ( example script)

Iteration

* * *

Job IDs, table

jot, Emit a sequence of integers. Equivalent to seq.

Random sequence generation

* * *

Keywords

kill, terminate a process by process ID

Options (-l, -9)

killall, terminate a process by name

killall script in /etc/rc.d/init.d

* * *

-le , less-than or equal integer comparison test

let, setting and carrying out arithmetic operations on variables

C-style increment and decrement operators

Limit string, in a here document

$LINENO, variable indicating the line number where it appears in a script

Link, file (using ln command)

Invoking script with multiple names, using ln
symbolic links, ln -s

List constructs

Local variables

and recursion

Localization

Logical operators (&&, ||, etc.)

Logout file, the ~/.bash_logout file

Loops

break loop control command
continue loop control command
C-style loop within double parentheses
for loop
while loop
do (keyword), begins execution of commands within a loop
done (keyword), terminates a loop
for loops
for arg in [list]; do
Command substitution to generate [list]
Filename expansion in [list]
Multiple parameters in each [list] element
Omitting [list], defaults to positional parameters
Parameterizing [list]
Redirection
in, (keyword) preceding [list] in a for loop
Nested loops
Running a loop in the background, script example
Semicolon required, when do is on first line of loop
for loop
while loop
until loop
until [ condition-is-true ]; do
while loop
while [ condition ]; do
Function call inside test brackets
Multiple conditions
Omitting test brackets
Redirection
while read construct
Which type of loop to use

Loopback devices

-lt , less-than integer comparison test

* * *

m4, macro processing language

$MACHTYPE, Machine type

Magic number, marker at the head of a file indicating the file type

Makefile, file containing the list of dependencies used by make command

Man page editor (script)

Math commands

Meta-meaning

Modulo, arithmetic remainder operator

Application: Generating prime numbers

Mortgage calculations, example script

* * *

-n String not null test

Named pipe, a temporary FIFO buffer

Example script

nc, netcat, a toolkit for TCP and UDP ports

-ne, not-equal-to integer comparison test

Negation operator, !, reverses the sense of a test

netstat, Network statistics

nl, a filter to number lines of text

Noclobber, -C option to Bash to prevent overwriting of files

NOT logical operator, !

null variable assignment, avoiding

* * *

-o Logical OR compound comparison test

od, octal dump

$OLDPWD Previous working directory

Operator

Options, passed to shell or script on command line or by set command

Or list

Or logical operator, ||

* * *

Parameter substitution

${parameter+alt_value}
${parameter:+alt_value}
Alternate value of parameter, if set
${parameter-default}
${parameter:-default}
${parameter=default}
${parameter:=default}
Default parameters
${!varprefix*}
${!varprefix@}
Parameter name match
${parameter?err_msg}
Parameter-unset message
${parameter}
Value of parameter
Script example
Table of parameter substitution

Parent / child process problem, a child process cannot export variables to a parent process

Parentheses

Command group
Enclose group of Extended Regular Expressions
Double parentheses, in arithmetic expansion

$PATH, the path (location of system binaries)

Perl, programming language

Combined in the same file with a Bash script
Embedded in a Bash script
Using eval with

Perquackey-type anagramming game (Quackey script)

Petals Around the Rose

PID, Process ID, an identification number assigned to a running process.

Pipe, | , a device for passing the output of a command to another command or to the shell

Avoiding unnecessary commands in a pipe
Pipefail, set -o pipefail option to indicate exit status within a pipe
$PIPESTATUS, exit status of last executed pipe
Piping output of a command to a script
Redirecting stdin, rather than using cat in a pipe

Pitfalls

- (dash) is not redirection operator
// (double forward slash), behavior of cd command toward
#!/bin/sh script header disables extended Bash features
Abuse of cat
CGI programming, using scripts for
Closing limit string in a here document, indenting
DOS-type newlines (\r\n) crash a script
eval, risk of using
Execute permission lacking for commands within a script
Export problem, child process to parent process
Extended Bash features not available
Failing to quote variables within test brackets
GNU command set, in cross-platform scripts
Multiple echo statements in a function whose output is captured
null variable assignment
Numerical and string comparison operators not equivalent
= and -eq not interchangeable
Omitting terminal semicolon, in a curly-bracketed code block
Piping
echo to a loop
echo to read
tail -f to grep
Preserving whitespace within a variable, unintended consequences
suid commands inside a script
Undocumented Bash features, danger of
Uninitialized variables
Variable names, inappropriate
Variables in a subshell, scope limited
Whitespace, misuse of

Pointers

Portability issues in shell scripting

Positional parameters

$@, as separate words
$*, as a single word

POSIX, Portable Operating System Interface / UNIX

$PPID, process ID of parent process

Precedence, operator

Prepending lines at head of a file, script example

Prime numbers

Generating primes using the factor command
Generating primes using the modulo operator
Sieve of Eratosthenes, example script

printf, formatted print command

/proc directory

Running processes, files describing
Writing to files in /proc, warning

Process

Process substitution

Prompt

$PS1, Main prompt, seen at command line
$PS2, Secondary prompt

Pseudo-code, as problem-solving method

$PWD, Current working directory

* * *

Quackey, a Perquackey-type anagramming game (script)

Question mark, ?

Character match in an Extended Regular Expression
Single-character wild card, in globbing
In a C-style Trinary operator

Quoting

Character string
Variables
within test brackets
Whitespace, using quoting to preserve

* * *

Random numbers

/dev/urandom
rand(), random function in awk
$RANDOM, Bash function that returns a pseudorandom integer
Random sequence generation, using date command
Random sequence generation, using jot
Random string, generating

rcs

read, set value of a variable from stdin

Recursion

Redirection

Code blocks
exec <filename,
to reassign file descriptors
Introductory-level explanation of I/O redirection
Open a file for both reading and writing
<>filename
read input redirected from a file
stderr to stdout
2>&1
stdin / stdout, using -
stdinof a function
stdout to a file
> ... >>
stdout to file descriptor j
>&j
file descriptori to file descriptor j
i>&j
stdout of a command to stderr
>&2
stdout and stderr of a command to a file
&>
tee, redirect to a file output of command(s) partway through a pipe

Reference Cards

Regular Expressions

^ (caret) Beginning-of-line
$ (dollar sign) Anchor
. (dot) Match single character
* (asterisk) Any number of characters
[ ] (brackets) Enclose character set to match
\ (backslash) Escape, interpret following character literally
\< ... \> (angle brackets, escaped) Word boundary
Extended REs
+ Character match
\{ \} Escaped "curly" brackets
[: :] POSIX character classes

$REPLY, Default value associated with read command

Restricted shell, shell (or script) with certain commands disabled

return, command that terminates a function

run-parts

Running scripts in sequence, without user intervention

* * *

Scope of a variable, definition

Script options, set at command line

Scripting routines, library of useful definitions and functions

Secondary prompt, $PS2

Security issues

sed, pattern-based programming language

Table, basic operators
Table, examples of operators

select, construct for menu building

in list omitted

Semaphore

Semicolon required, when do keyword is on first line of loop

When terminating curly-bracketed code block

seq, Emit a sequence of integers. Equivalent to jot.

set, Change value of internal script variables

Shell script, definition of

Shell wrapper, script embedding a command or utility

shift, reassigning positional parameters

$SHLVL, shell level, depth to which the shell (or script) is nested

shopt, change shell options

Signal, a message sent to a process

Simulations

Brownian motion
Galton board
Horserace
Life, game of
PI, approximating by firing cannonballs
Pushdown stack

Single quotes (' ... ') strong quoting

Socket, a communication node associated with an I/O port

Sorting

source, execute a script or, within a script, import a file

Passing positional parameters

Spam, dealing with

Special characters

Stack, emulating a push-down, example script

Standard Deviation, example script

Startup files, Bash

stdin and stdout

Strings

=~ String match operator
Comparison
Length
${#string}
Manipulation
Manipulation, using awk
Protecting strings from expansion and/or reinterpretation, script example
Unprotecting strings, script example
strchr(), equivalent of
strlen(), equivalent of
strings command, find printable strings in a binary or data file
Substring extraction
${string:position}
${string:position:length}
Using expr
Substring index (numerical position in string)
Substring matching, using expr
Substring removal
${var#Pattern}
${var##Pattern}
${var%Pattern}
${var%%Pattern}
Substring replacement
${string/substring/replacement}
${string//substring/replacement}
${string/#substring/replacement}
${string/%substring/replacement}
Script example
Table of string/substring manipulation and extraction operators

Strong quoting ' ... '

Stylesheet for writing scripts

Subshell

Command list within parentheses
Variables, $BASH_SUBSHELL and $SHLVL
Variables in a subshell
scope limited, but ...
... can be accessed outside the subshell?

su Substitute user, log on as a different user or as root

suid (set user id) file flag

suid commands inside a script, not advisable

Symbolic links

Swapfiles

* * *

Table lookup, script example

tail, echo to stdout lines at the (tail) end of a text file

tar, archiving utility

tee, redirect to a file output of command(s) partway through a pipe

Terminals

test command

Bash builtin
external command, /usr/bin/test (equivalent to /usr/bin/[)

Test constructs

Test operators

-a Logical AND compound comparison
-e File exists
-eq is-equal-to (integer comparison)
-f File is a regular file
-ge greater-than or equal (integer comparison)
-gt greater-than (integer comparison)
-le less-than or equal (integer comparison)
-lt less-than (integer comparison)
-n not-zero-length (string comparison)
-ne not-equal-to (integer comparison)
-o Logical OR compound comparison
-u suid flag set, file test
-z is-zero-length (string comparison)
= is-equal-to (string comparison)
== is-equal-to (string comparison)
< less-than (string comparison)
< less-than, (integer comparison, within double parentheses)
<= less-than-or-equal, (integer comparison, within double parentheses)
> greater-than (string comparison)
> greater-than, (integer comparison, within double parentheses)
>= greater-than-or-equal, (integer comparison, within double parentheses)
|| Logical OR
&& Logical AND
! Negation operator, inverts exit status of a test
!= not-equal-to (string comparison)
Tables of test operators
Binary comparison
File