Index

Beginning-of-line, in a Regular Expression

^

^^

Uppercase conversion in parameter substitution

~ home directory, corresponds to $HOME

~/ Current user's home directory

~+ Current working directory

~- Previous working directory

= Variable assignment operator

= String comparison operator

== String comparison operator

=~ Regular Expression match operator

Example script

Is-less-than

String comparison

Integer comparison within double parentheses

Redirection

< stdin

<< Here document

<<< Here string

<> Opening a file for both reading and writing

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

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

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

;;& ;& Terminators in a case option (version 4+ of Bash).

:> filename Truncate file to zero length

null command, equivalent to the true Bash builtin

Used in an anonymous here document

Used in an otherwise empty function

Used as a function name

!= not-equal-to String comparison operator

Match zero or one characters, in an Extended Regular Expression

Single-character wild card, in globbing

In a C-style Trinary operator

. 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

Double-quoting the backslash (\) character

Comma operator

,

,,

Lowercase conversion in parameter substitution

( ... ) Command group; starts a subshell

( ... ) Enclose group of Extended Regular Expressions

>( ... )

<( ... ) Process substitution

... ) Terminates test-condition in case construct

(( ... )) Double parentheses, in arithmetic expansion

Array element

Enclose character set to match in a Regular Expression

Test construct

${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

\< ... \> 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

Wild card, in globbing

Any number of characters in a Regular Expression

** Exponentiation, arithmetic operator

** Extended globbing file-match operator

Modulo, division-remainder arithmetic operation

Substring removal (pattern matching) operator

Character match, in an extended Regular Expression

Prefix to alternate parameter, in parameter substitution

++ C-style variable increment, within double parentheses

Removing an alias, using unalias

To supply default command-line argument

rpm

tar

exit status of

variations of

combination operators, C-style

+= -= *= /= %=

Associative arrays

more efficient than conventional 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

Definition

Scripts for generating ASCII table

rand(), random function

String manipulation

Using export to pass a variable to an embedded awk script

Bad scripting practices

Basics reviewed, script example

Command-line options

Table

Features that classic Bourne shell lacks

Internal variables

Version 2

Version 3

Version 4

Version 4.1

Version 4.2

In a here document

Template for calculating a script variable

Example script

testing for

Iterating / looping

Redirection

Script example: Redirecting output of a a code block

Extended, {a..z}

Parameterizing

With increment and zero-padding (new feature in Bash, version 4)

Array element

Enclose character set to match in a Regular Expression

Test construct

Code block

find

Extended Regular Expressions

Positional parameters

xargs

Parameter (optional)

Do not fork a subprocess

Command-line parameters, handling

Globbing, filtering strings with

Abuse of

cat scripts

Less efficient than redirecting stdin

Piping the output of, to a read

Uses of

testing for

Cycling through the background colors, example script

Table of color escape sequences

Template, colored text on colored background

$( ... ), preferred notation

Backquotes

Extending the Bash toolset

Invokes a subshell

Nesting

Removes trailing newlines

Setting variable from loop output

Word splitting

Using an anonymous here document

Using an if-then construct

bzip2

compress

gzip

zip

Control-C, break

Control-D, terminate / log out / erase

Control-G, BEL (beep)

Control-H, rubout

Control-J, newline

Control-M, carriage return

in find command

in an Extended Regular Expression

in xargs

Conversions

Copying raw data to/from devices

File deletion, secure

Keystrokes, capturing

Options

Random access on a data stream

Raspberry Pi, script for preparing a bootable SD card

Swapfiles, initializing

Thread on www.linuxquestions.org

Tools

Trapping at exit

Trapping signals

options

case-modification options (version 4+ of Bash)

/dev/null pseudo-device file

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

/dev/zero, pseudo-device file

and evaluation of octal/hex constants

Double-quoting the backslash (\) character

Feeding commands down a pipe

Setting a variable using command substitution

/bin/echo, external echo command

Within $' ... ' string expansion

Used with Unicode characters

Effects of, Example script

Forces reevaluation of arguments

And indirect references

Risk of using

Using eval to convert array elements into a command list

Using eval to select among variables

exit command

Exit status (exit code, return status of a command)

Table, Exit codes with special meanings

Anomalous

Out of range

Pipe exit status

Specified by a function return

Successful, 0

/usr/include/sysexits.h, system file listing C/C++ standard exit codes

Passing a variable to an embedded awk script

Substring extraction

Substring index (numerical position in string)

Substring matching

? (question mark) Match zero / one characters

( ... ) Group of expressions

\{ N \} “Curly” brackets, escaped, number of character sets to match

+ Character match

Application: Generating prime numbers

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

{} Curly brackets

\; Escaped semicolon

Using - with file-processing utility as a filter

Feeding output of a filter back to same filter

Arguments passed referred to by position

Capturing the return value of a function using echo

Colon as function name

Definition must precede first call to function

Exit status

Local variables

and recursion

Passing an array to a function

Passing pointers to a function

Positional parameters

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

Unusual function names

Anagrams

Anagrams, again

Bingo Number Generator

Crossword puzzle solver

Crypto-Quotes

Dealing a deck of cards

Fifteen Puzzle

Horse race

Knight's Tour

“Life” game

Magic Squares

Music-playing script

Nim

Pachinko

Perquackey

Petals Around the Rose

Podcasting

Poem

Speech generation

Towers of Hanoi

Graphic version

Alternate graphic version

Emulated in a script

$OPTIND / $OPTARG

Handling filenames correctly

Wild cards

Will not match dot files

Example script

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

Calculating the Golden Ratio

Prepending text

As the stdin of a loop

Using read

Limit string

! as a 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

if-grep, if and grep in combination

Fixup for if-grep test

Defaults to whitespace

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

Usage example

Example script

Random sequence generation

error, if missing

Options (-l, -9)

C-style increment and decrement operators

Invoking script with multiple names, using ln

symbolic links, ln -s

And list

Or list

and recursion

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

In /dev directory

Mounting an ISO image

Man page editor (script)

Application: Generating prime numbers

Example script

Colon as function name

Homework assignment

Just another Bash hacker!

Definition of

Precedence

${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

Case modification (version 4+ of Bash).

Script example

Table of parameter substitution

Command group

Enclose group of Extended Regular Expressions

Double parentheses, in arithmetic expansion

Appending directories to $PATH using the += operator.

Parsing pathnames

Combined in the same file with a Bash script

Embedded in a Bash script

Avoiding unnecessary commands in a pipe

Comments embedded within

Exit status of 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

- (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

Double-quoting the backslash (\) character

eval, risk of using

Execute permission lacking for commands within a script

Exit status, anomalous

Exit status of arithmetic expression not equivalent to an error code

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

let misuse: attempting to set string variables

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 (however, this problem can be circumvented)

tail -f to grep

Preserving whitespace within a variable, unintended consequences

suid commands inside a script

Undocumented Bash features, danger of

Updates to Bash breaking older scripts

Uninitialized variables

Variable names, inappropriate

Variables in a subshell, scope limited

Subshell in while-read loop

Whitespace, misuse of

and file descriptors

and functions

and indirect references

and variables

Setting path and umask

A test suite script (Bash versus classic Bourne shell)

Using whatis

$@, as separate words

$*, as a single word

in functions

--posix option

1003.2 standard

Character classes

Generating primes using the factor command

Generating primes using the modulo operator

Sieve of Eratosthenes, example script

Running processes, files describing

Writing to files in /proc, warning

Child process

Parent process

Process ID (PID)

To compare contents of directories

To supply stdin of a command

Template

while-read loop without a subshell

$PS1, Main prompt, seen at command line

$PS2, Secondary prompt

Character match in an Extended Regular Expression

Single-character wild card, in globbing

In a C-style Trinary (ternary) operator

Character string

Variables

within test brackets

Whitespace, using quoting to preserve

/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

Script for preparing a bootable SD card

Detecting arrow keys

Options

Piping output of cat to read

“Prepending” text

Problems piping echo to read

Redirection from a file to read

$REPLY, default read variable

Timed input

while read construct

Demonstration of

Factorial

Fibonacci sequence

Local variables

Script calling itself recursively

Towers of Hanoi

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

Miscellaneous constructs

Parameter substitution/expansion

Special shell variables

String operations

Test operators

Binary comparison

Files

^ (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

Running scripts in sequence, without user intervention

nmap, network mapper / port scanner

sudo

suid commands inside a script

Viruses, trojans, and worms in scripts

Writing secure scripts

Table, basic operators

Table, examples of operators

in list omitted

When terminating curly-bracketed code block

set -u, Abort script with error message if attempting to use an undeclared variable.

Brownian motion

Galton board

Horserace

Life, game of

PI, approximating by firing cannonballs

Pushdown stack

Bubble sort

Insertion sort

Passing positional parameters

Example script

Example script

Example script

Example script

Definition

Emulating a push-down stack, example script

=~ String match operator

Comparison

Length

${#string}

Manipulation

Manipulation, using awk

Null string, testing for

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

Command list within parentheses

Variables, $BASH_SUBSHELL and $SHLVL

Variables in a subshell

scope limited, but ...

... can be accessed outside the subshell?

suid commands inside a script, not advisable

setserial

setterm

stty

tput

wall

Bash builtin

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

-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

Using read -t

Using stty

Using timing loop

Using $TMOUT

Array, as return value from a function

Associative array more efficient than a numerically-indexed array

Capturing the return value of a function, using echo

CGI programming, using scripts for

Comment blocks

Using anonymous here documents

Using if-then constructs

Comment headers, special purpose

C-style syntax , for manipulating variables

Double-spacing a text file

Filenames prefixed with a dash, removing

Filter, feeding output back to same filter

Function return value workarounds

if-grep test fixup

Library of useful definitions and functions

null variable assignment, avoiding

Passing an array to a function

$PATH, appending to, using the += operator.

Prepending lines at head of a file

Progress bar template

Pseudo-code

rcs

Redirecting a test to /dev/null to suppress output

Running scripts in sequence without user intervention, using run-parts

Script as embedded command

Script portability

Setting path and umask

Using whatis

Setting script variable to a block of embedded sed or awk code

Speeding up script execution by disabling unicode

Subshell variable, accessing outside the subshell

Testing a variable to see if it contains only digits

Testing whether a command exists, using type

Tracking script usage

while-read loop without a subshell

Widgets, invoking from a script

DOS to Unix text file conversion

Options

Soundex, example script

Variants

in double-parentheses construct

in let construct

options

Disabling unicode to optimize script

Array operations on

Assignment

Script example

Script example

Script example

Bash internal variables

Block of sed or awk code, setting a variable to

C-style increment/decrement/trinary operations

Change value of internal script variables using set

declare, to modify the properties of variables

Deleting a shell variable using unset

Environmental

Expansion / Substring replacement operators

Indirect referencing

eval variable1=\$$variable2

Newer notation

${!variable}

Integer

Integer / string (variables are untyped)

Length

${#var}

Lvalue

Manipulating and expanding

Name and value of a variable, distinguishing between

Null string, testing for

Null variable assignment, avoiding

Quoting

within test brackets

to preserve whitespace

rvalue

Setting to null value

In subshell not visible to parent shell

Testing a variable if it contains only digits

Typing, restricting the properties of a variable

Undeclared, error message

Uninitialized

Unquoted variable, splitting

Unsetting

Untyped

To remedy script hang

C-style syntax

Calling a function within test brackets

Multiple conditions

Omitting test brackets

while read construct

Avoiding a subshell

$IFS defaults to

Inappropriate use of

Preceding closing limit string in a here document, error

Preceding script comments

Quoting, to preserve whitespace within strings or variables

[:space:], POSIX character class

w

whoami

logname

Asterisk *

In [list] constructs

Question mark ?

Will not match dot files

Definition

Resulting from command substitution

Curly brackets

Limiting arguments passed

Options

Processes arguments one at a time

Whitespace, handling

Emulation