This article is a brief summary of the Bash Reference Manual.

Table of Contents

Basic Concepts

• control operator: used to control methods (to separate commands): newline || && & ; ;; ;& ;;& | |& ( )
• metacharacter: used to separate words (word): | & ; ( ) < >
• The process Bash follows to execute a command is as follows:
  1. Read commands from a file or terminal;
  2. Split the input into words (word) and operators (operator); quoting rules (Quoting) are applied in this step. Words are separated by metacharacter. Alias expansion is performed at this step;
  3. Parse tokens (token) into simple (simple) and compound (compound) commands;
  4. Perform various expansions (expansion) (see below for expansion order), and put the expanded words into commands and arguments;
  5. Perform necessary redirections (redirection), and remove redirection operators from the argument list;
  6. Execute the command;
  7. Optionally wait for the command to complete and obtain the exit status.
• Quoting rules:
  • \ escapes the next character; \newline is treated as line joining. Unless inside single quotes ', the result of the escape will not contain a newline (that is, \n);
  • ' quotes all characters appearing inside the quotes;
  • " quotes all characters except $ ` \ !. $ and ` retain their full expansion meaning. \ only has escaping semantics when followed by $ ` " \ newline; otherwise it is output as a backslash. If history expansion is enabled, ! will expand; if ! is escaped by \, it will not expand, and the \ will not be removed (it still outputs as \!);
  • ANSI-C quoting, in the form $'\n', is interpreted using ANSI C escape semantics, for example:
    • \nnn: octal escape (up to 3 digits);
    • \xHH: hexadecimal escape (up to 2 digits);
    • \uHHHH: Unicode escape (up to 4 digits);
    • \UHHHHHHHH: Unicode escape (up to 8 digits);
    • \cx: control-x escape.
• | and |& form a pipeline. If ! is added in front of the pipeline, the final exit code is logically negated, for example ! ls (the space cannot be omitted, otherwise it is parsed as history expansion). |& redirects both stdout and stderr;
• ; & && || form a list, and the end of the list is marked by ; & newline, among which && || have the highest precedence, followed by ; &. Commands marked with & run in the background. If job control is not enabled, the process’s stdin will be redirected to /dev/null;
• ( list ) creates a subshell and then executes the commands; { list; } executes the commands in the current shell. Note that the space and the ; cannot be omitted;
• coproc creates a coprocess;
• parallel is similar to xargs, but executes commands in parallel;

Basic Syntax

In the syntax, most ; can be replaced by newline.

Loops

until test-commands; do      # Loop until test-commands returns 0
	consequent-commands;
done # exitcode is the exit code of the last command executed; if no commands are executed, it is 0

while test-commands; do      # Loop while test-commands does not return 0
	consequent-commands;
done # exitcode is the exit code of the last command executed; if no commands are executed, it is 0

for name [ [in [words …] ] ; ] do  # If the in clause is omitted, it is equivalent to in "$@"
	commands $name; 
done # exitcode is the exit code of the last command executed; if no commands are executed, it is 0

for (( expr1 ; expr2 ; expr3 )) ; do  # This is Bash-specific syntax
	commands; 
done # exitcode is the exit code of the last command executed; if any expr is invalid, it returns false

Conditionals

if test-commands; then
	consequent-commands;
elif more-test-commands; then
	more-consequents;
else
	alternate-consequents;
fi # exitcode is the exit code of the last command executed; if no condition is true, returns 0

case word in 
	pattern1 | pattern2) command-list1 ;;  # If it matches and ends with ;;, return immediately
	pattern3 | pattern4) command-list2 ;&  # If it matches and ends with ;&, continue executing the next command-list
	pattern5 | pattern6) command-list3 ;;& # If it matches and ends with ;;&, continue matching the next item, and execute when matched
	*) command-list ;;
esac # exitcode is the exit code of the command-list executed; if there is no match, returns 0

select name [in words …]; do # Construct a menu for the user to choose from
	commands $name $REPLY; # $REPLY holds the selected index
	break;                 # break exits the select environment; otherwise select is executed repeatedly
done

(( expression ))  # Bash arithmetic expression; if the expression is non-zero, exitcode is 0, otherwise exitcode is 1
[[ expression ]]  # Bash conditional expression

Bash Conditional Expressions (Bash Extensions)

Unless otherwise specified, files are followed through symbolic links and operations are performed on the target file rather than on the symbolic link itself.

Functions

Use local inside functions to define local variables.

name () compound-command [ redirections ]

# The command must end with ; & or newline
function name [()] compound-command [ redirections ]

Special Parameters

Expansion

Shell expansions are performed in the following order:

1. Brace expansion;
2. Tilde expansion, parameter and variable expansion, arithmetic expansion, command substitution, process substitution, from left to right;
3. Word splitting;
4. Filename expansion (wildcards);
5. Quote removal.

Expansion syntaxes:

Parameter expansion forms:

• ${parameter:-word}: If parameter is unset, expand to word; otherwise expand to parameter;
• ${parameter:=word}: If parameter is unset, assign the value obtained by expanding word to parameter, and then expand it;
• ${parameter:?word}: If parameter is unset, output the expanded word to stderr; if the shell is non-interactive, exit;
• ${parameter:+word}: If parameter is unset, substitute nothing; otherwise substitute the expansion of word;
• ${parameter:offset} ${parameter:offset:length}: Take a substring of parameter. When offset and length are negative, they count from the end of the string; when offset is negative, there must be a space between : and -;
• ${!prefix*} ${!prefix@}: Expand the names of variables whose names begin with prefix and join them using $IFS;
• ${!name[@]} ${!name[*]}: If name is an array (or associative array), expand to its indices (or keys). If not, then if name is defined, expand to 0; otherwise to null. If @ is used, each key is expanded as a separate "-quoted word;
• ${#parameter}: Expand to the length of the array;
• ${parameter#word}: Expand after removing the shortest match of word from the beginning of parameter;
• ${parameter##word}: Expand after removing the longest match of word from the beginning of parameter;
• ${parameter%word}: Expand after removing the shortest match of word from the end of parameter;
• ${parameter%%word}: Expand after removing the longest match of word from the end of parameter;
• ${parameter/pattern/string}: Expand after replacing the part of parameter that matches pattern with string. pattern can begin with:
  • /: replace all matches; by default only the first match is replaced;
  • #: the match must start at the beginning;
  • %: the match must include the end.
• ${parameter^pattern} ${parameter^^pattern} ${parameter,pattern} ${parameter,,pattern}: Find parts of parameter matching pattern and change their case. ^ ^^ convert lowercase to uppercase; , ,, convert uppercase to lowercase. ^ , convert only once; ^^ ,, convert all matches. If pattern is omitted, it is equivalent to matching the entire content.

When filename expansion is performed and the extglob option is enabled (via shopt), the following patterns are also supported:

• ?(pattern-list) matches zero or one occurrence
• *(pattern-list) matches zero or more occurrences
• +(pattern-list) matches one or more occurrences
• @(pattern-list) matches exactly one occurrence
• !(pattern-list) matches any string except those that match pattern-list

Redirection

Bash uses some special files in redirections. If the operating system supports these files, Bash uses the OS-provided files; otherwise Bash simulates them:

Redirection Syntax

Arrays and Associative Arrays

Defining arrays:

• name[subscript]=value
• declare -a name
• name=(value1 value2 ... )

Defining associative arrays:

• declare -A name

Referencing elements of arrays or associative arrays:

• ${name[subscript]}

Shell Builtins

• Use help cmd to obtain help for a shell builtin;
• Use type cmd to check whether cmd is a shell builtin;
• trap: set a signal handler. Example:

trap "echo SIGINT" 2    # Set a handler for SIGINT
trap - 2                # Clear the handler

Line Editing

Bash uses readline for line editing. readline attempts to read the configuration file specified by the shell variable INPUTRC; if the variable does not exist, it reads ~/.inputrc; if that file does not exist, it reads /etc/inputrc.

Use bind -P to list all current key bindings and their functions, where

• \C-x means ctrl-x;
• \M-x means Meta-x, usually the alt key;
• \C-\M-x means press ctrl and alt simultaneously;
• \ex means Esc-x.

Use bind -V to list the current settings. For example, bind "set completion-disabled on" disables automatic completion.