Basic Shell Features

n.b. if needs  space before [ and
[ x comparison y ] needs spaces around comparison
examples:

    ./myscript.sh
    RC=$?
    if [ $RC -ne 0 ]; then echo myscript failed exit status= $RC ; fi

    ./yourscript.sh
    if [ $? -eq 0 ]; then echo yourscript worked, no cleanup needed; exit; fi

    if [ $? ]; then echo  always true ; fi (remind me why this is?)




    if [ -z "$PS1" ]; then
            echo This shell is not interactive
       else
            echo This shell is interactive
     fi

The very simple (but not as clear)
If first command works, execute second command 
    ./setup.sh   && ./process.sh


IF first command fails, execute second command 
    ./checkIt  ||  { echo "checkIt failed"  ; exit 1; } 

(see Lists of Commands )

select

select name [in words … ]; do commands; done

1. The list of words is expanded, generating a list of items.
2. These items are printed on the standard error output stream, each preceded by a number. If the in words is omitted, the positional parameters are printed, as if in "$@" had been specifed.
3. The PS3 prompt is then displayed and a line is read from the standard input.
4. If the line consists of a number corresponding to one of the displayed words, then the value of name is set to that word. If the line is empty, the words and prompt are displayed again.
5. Other values causes name to be set to null.
6. If EOF is read, the select command completes. The line read is saved in the variable REPLY.
7. The commands are executed after each selection until a break or return command is executed, at which point the select command completes.

 select fname in  0.sh birdloger* *.sed ;
      do  
        echo you picked $fname \($REPLY\);    
        break;       
      done 

1) 0.sh                     3) birdloger.pl             5) log-summ.sed
2) birdloger.html           4) birdlogmail2content.sed  6) lslrClean.sed
#? 3
you picked birdloger.pl (3) 

(( arithmetic_expression ))

This is equivalent to

let "expression"

[[ conditional_expression ]]

When the == and != operators are used, the string to the right of the operator is considered a pattern and matched according to the rules described below in section Pattern Matching. The return value is 0 if the string matches or does not match the pattern, respectively, and 1 otherwise. Any part of the pattern may be quoted to force it to be matched as a string. Expressions may be combined using the following operators, listed in decreasing order of precedence:

( expression )

Returns the value of expression. This may be used to override the normal precedence of operators.

! expression

True if expression is false.

expression1 && expression2

True if both expression1 and expression2 are true.

expression1 || expression2

True if either expression1 or expression2 is true.

Grouping Commands

(  list  )

Parentheses cause the commands to be executed in a new subshell.
Variable assignments do not remain in effect after the subshell completes.

{  list  ;  }

Curly braces cause the list to be executed in the current shell context.
The semicolon is required.
Braces are reserved words and must be separated from the list by blanks.

The exit status of a group is the exit status of list .

Functions

Functions are declared using :
[ function ] func () { command-list; }

This defines a shell function named func.
The reserved word function is optional.
If the function reserved word is supplied, the parentheses are optional.
The body of the function is the command-list between { and }.
This list is executed whenever func is specified as the name of a command.
The exit status of a function is the exit status of the last command executed in the body.

When a function is executed, the arguments to the function become the positional parameters during its execution.
The special parameter $#, the number of positional parameters, is updated to reflect the change. Positional parameter $0 is unchanged.

If the builtin command return is executed in a function, the function completes and execution resumes with the next command after the function call. When a function completes, the values of the positional parameters and the special parameter $# are restored to the values they had prior to the function's execution.
If a numeric argument is given to return, that is the function's return status; otherwise it is the status of the last command executed.

The status of a simple command is its exit status as provided by the POSIX.1 waitpid function, or 128+n if the command was terminated by signal†??(_) n.

Variables local to the function may be declared with the local builtin. These variables are visible only to the function and the commands it invokes.

Functions may be recursive. No limit is placed on the number of recursive calls.

Shell Parameters

A parameter is set if it has been assigned a value. The null string is a valid value. Once a variable is set, it may be unset only by using the unset builtin.

A variable may be assigned to by a statement of the form

name=[value]

If value is not given, the variable is assigned the null string. All values undergo tilde expansion, parameter and variable expansion, command substitution, arithmetic expansion, and quote removal . If the variable has its integer attribute set (see declare Builtin Commands), then value is subject to arithmetic expansion even if the $((...)) expansion is not used (see Arithmetic Expansion).
Word splitting is not performed, with the exception of "$@" .
Filename expansion is not performed.

Positional Parameters

A positional parameter is a parameter denoted by one or more digits, other than the single digit 0. Positional parameters are assigned from the shell's arguments when it is invoked, and may be reassigned using the set builtin command.
Positional parameter N may be referenced as ${N}.
Positional parameters may not be assigned to with assignment statements.
The positional parameters are temporarily replaced when a shell function is executed (see Shell Functions).

When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces.

Expansions

Expansions, substitution and splitting are performed on the command line after it has been split into tokens.

1. brace expansion
2. tilde expansion
3. parameter and variable expansion
4. command substitution
5. arithmetic expansion
6. word splitting
7. filename expansion

On some systems process substitution is performed at the same time as parameter, variable, and arithmetic expansion and command substitution.

brace expansion, word splitting, filename expansion and "$@" can change the number of words of the expansion. Special Parameters and "${name[@]}" (see Arrays).

After all expansions, Quote Removal is performed.

Brace Expansion

Brace expansions may be nested. The results of each expanded string are not sorted; left to right order is preserved. For example,

echo a{d,c,b}e
ade ace abe

Brace expansion is performed before any other expansions, and any characters special to other expansions are preserved in the result. It is strictly textual. no syntactic interpretation is done to the context of the expansion or the text between the braces.

This construct is typically used as shorthand when the common prefix of the strings to be generated is longer than in the above example:

mkdir /usr/local/src/bash/{old,new,dist,bugs}
expands to:
mkdir /usr/local/src/bash/old
mkdir /usr/local/src/bash/new
mkdir /usr/local/src/bash/dist
mkdir /usr/local/src/bash/bugs

or

chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

When a word begins with a tilde (~), the next characters, up to a /, (or all characters, if there is no / ) are refered to as hdir^†  
~hdir is replaced with the home directory of the user from (/etc/passwd).

  echo ~mjones  
  /users/mjones

  echo ~
  /users/jsmith  

When the backquote (`) form of substitution is used, backslash(\) retains its literal meaning except for \\, \$ or \`
When using the $(command) form, all characters between the parentheses make up the command; none are treated specially.

Command substitutions may be nested. To nest when using the backquoted form, escape the inner backquotes with backslashes.

If the substitution appears within double quotes ("), word splitting and filename expansion are not performed on the results.

Arithmetic Expansion

Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is:

$(( expression ))

expression treated as if it were within double quotes, but a double quote inside the parentheses is not treated specially.
All tokens in the expression undergo parameter expansion, command substitution, and quote removal. Arithmetic substitutions may be nested.

The evaluation is performed according to the rules †
If the expression is invalid, Bash displays a message indicating failure to the standard error and no substitution occurs.

Process Substitution

Takes the form   <(list)   or   >(list)

The process list is run with its input or output connected to a FIFO or some file in /dev/fd. The name of this file is passed as an argument to the current command as the result of the expansion.
>(list) form : writing to the file will provide input for list.
<(list) form : the file passed as an argument should be read to obtain the output of list.

Process substitution is performed simultaneously with parameter and variable expansion, command substitution, and arithmetic expansion.

Word Splitting

Each character of $IFS† is a delimiter, and splits the results of the other expansions into words.
If IFS is unset, or its value is exactly <space><tab><newline>, the default, then any sequence of IFS characters serves to delimit words.
If IFS has a value other than the default, then sequences of the whitespace characters space and tab are ignored at the beginning and end of the word, as long as the whitespace character is in the value of IFS (an IFS whitespace character).
Any character in IFS that is not IFS whitespace, along with any adjacent IFS whitespace characters, delimits a field.
A sequence of IFS whitespace characters is also treated as a delimiter.
If the value of IFS is null, no word splitting occurs.

Explicit null arguments ("" or '') are retained.
Unquoted implicit null arguments, resulting from the expansion of parameters that have no values, are removed.
If a parameter with no value is expanded within double quotes, a null argument results and is retained.
If no expansion occurs, no splitting is performed.

Filename Expansion (globbing)

Filenames that match one of the patterns in GLOBIGNORE are removed from the list of matches.
Setting GLOBIGNORE implies dotglob, so filenames beginning with a . will match. To get the old behavior of ignoring filenames beginning with a ., make .* one of the patterns in GLOBIGNORE.
dotglob is disabled when GLOBIGNORE is unset.

ls u*	lists files beginning with lower case u
ls [uU]*	lists files beginning with lower case u OR upper case U

Pattern Matching

The special pattern characters have the following meanings: A ] may be matched by including it as the first character in the set.

In the default C locale, [a-dx-z] is equivalent to [abcdxyz]. Some locales sort characters in dictionary order, in which case [a-dx-z] might be equivalent to [aBbCcDdxXyYz]†. To force the use of the C locale set the LC_COLLATEor LC_ALL environment variable to C.

*	Matches any string, including the null string.
?	Matches any single character.
[...]	Matches any one of the enclosed characters, ex: [Dd][Gg]erman .
[a-z]	denotes a range; any character that sorts between them, inclusive, is matched A - may be matched by including it as the first or last character in the set. If the first character following the [ is a ! or a ^ then any character not enclosed is matched. ex: [!~!@#$%^&*()_+|\=-{}:"';?><,./`,] EXCLUDES all non-alphanumeric characters.
[:class:]	character classes are where class is one of the following : alpha digit alnum ascii cntrl graph print punct blank space lower upper word xdigit A character class matches any character belonging to that class. The word character class matches letters, digits, and the character _ ex: [:alpha:] or [:space:].
[=c=]	equivalence class are matches all characters with the same collation weight (as defined by the current locale) as the character c.
[.symbol.]	matches the collating symbol symbol.

If extglob is enabled using the shopt builtin, several extended pattern matching operators are recognized.

In the following description, a pattern-list is a list of one or more patterns separated by a |.
Composite patterns may be formed using one or more of the following sub-patterns:

Quote Removal

After the preceding expansions, all unquoted occurrences of \, ', and "
that did not result from one of the above expansions are removed.

Redirections

Redirecting Input

Redirecting Output

Appending Redirected Output

Redirecting both STDOUT and STDERR

The order of redirections is significant.

ls -l > /tmp/stdout+stderr 2>&1

directs both standard output and standard error to the file

ls -l 2>&1 > /tmp/stdout directs only the standard output to the file , because the standard error was duplicated as standard output before the standard output was redirected .

Redirecting to /dev/null should be avoided. Instead use:

command > /tmp/$$.1 2> /tmp/$$.2
if [ $? > 0 | -e /tmp/$$.2 ] ; then echo " error \n"; cat /tmp/$$.2

Here Documents

No parameter expansion, command substitution, filename expansion, or arithmetic expansion is performed on word.
If any characters in word are quoted, the delimiter is the result of quote removal on word, and the lines in the here-document are not expanded.
If word is unquoted, all lines of the here-document are subjected to parameter expansion, command substitution, and arithmetic expansion.
The pair \newline is ignored, and \ must be used to quote the characters \, $, and `.

<<- all leading tab characters are stripped from input lines and the line containing delimiter. This allows here-documents within shell scripts to be indented in a natural fashion.

Duplicating File Descriptors

duplicates input file descriptors.
If n is not specified, the STDIN (file descriptor 0) is used. If fdes expands to one or more digits, the file descriptor (n) becomes a copy of that file descriptor.
If the digits in fdes do not specify a file descriptor open for input, a redirection error occurs.
If fdes evaluates to -, file descriptor n is closed.

[n]>&fdes duplicates output file descriptors.
If n is not specified, the standard output (file descriptor 1) is used.
If the digits in fdes do not specify a file descriptor open for output, a redirection error occurs. As a special case, if n is omitted, and fdes does not expand to one or more digits, STDOUT and STDERR are redirected .

Moving File Descriptors

[n]<&d-

moves the file descriptor d to file descriptor n, or the standard input if n is not specified.
d is closed after being duplicated to n.

[n]&d-

moves the file descriptor d to file descriptor n, or the standard output ifd is not specified.

Opening File Descriptors for Reading and Writing

Executing Commands

Simple Command Expansion

When a simple command is executed, the shell performs the following expansions, assignments, and redirections, from left to right.

1. The words that the parser has marked as variable assignments (those preceding the command name) and redirections are saved for later processing.
2. The words that are not variable assignments or redirections are expanded (see Shell Expansions). If any words remain after expansion, the first word is taken to be the name of the command and the remaining words are the arguments.
3. Redirections are performed as described above (see Redirections).
4. The text after the = in each variable assignment undergoes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before being assigned to the variable.

If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment. If any of the assignments attempts to assign a value to a readonly variable, an error occurs, and the command exits with a non-zero status.

If no command name results, redirections are performed, but do not affect the current shell environment. A redirection error causes the command to exit with a non-zero status.

If there is a command name left after expansion, execution proceeds as described below. Otherwise, the command exits. If one of the expansions contained a command substitution, the exit status of the command is the exit status of the last command substitution performed. If there were no command substitutions, the command exits with a status of zero.

Command Search and Execution

After a command has been split into words, if it results in a simple command and an optional list of arguments, the following actions are taken.

1. If the command name contains no slashes, the shell attempts to locate it. If there exists a shell function by that name, that function is invoked as described above in section Shell Functions.
2. If the name does not match a function, the shell searches for it in the list of shell builtins. If a match is found, that builtin is invoked.
3. If the name is neither a shell function nor a builtin, and contains no slashes, Bash searches each element of $PATH for a directory containing an executable file by that name. Bash uses a hash table to remember the full pathnames of executable files to avoid multiple PATH searches (see the description of hash in section Bourne Shell Builtins). A full search of the directories in $PATH is performed only if the command is not found in the hash table. If the search is unsuccessful, the shell prints an error message and returns an exit status of 127.
4. If the search is successful, or if the command name contains one or more slashes, the shell executes the named program in a separate execution environment. Argument 0 is set to the name given, and the remaining arguments to the command are set to the arguments supplied, if any.
5. If this execution fails because the file is not in executable format, and the file is not a directory, it is assumed to be a shell script and the shell executes it as described in section Shell Scripts.
6. If the command was not begun asynchronously, the shell waits for the command to complete and collects its exit status.

Command Execution Environment

The shell has an execution environment, which consists of the following:

• open files inherited by the shell at invocation, as modified by redirections supplied to the exec builtin
• the current working directory as set by cd, pushd, or popd, or inherited by the shell at invocation
• the file creation mode mask as set by umask or inherited from the shell's parent
• current traps set by trap
• shell parameters that are set by variable assignment or with set or inherited from the shell's parent in the environment
• shell functions defined during execution or inherited from the shell's parent in the environment
• options enabled at invocation (either by default or with command-line arguments) or by set
• options enabled by shopt
• shell aliases defined with alias (see Aliases)
• various process IDs, including those of background jobs (see Lists of Commands), the value of $$, and the value of $PPID

When a simple command other than a builtin or shell function is to be executed, it is invoked in a separate execution environment that consists of the following. Unless otherwise noted, the values are inherited from the shell.

• the shell's open files, plus any modifications and additions specified by redirections to the command
• the current working directory
• the file creation mode mask
• shell variables marked for export, along with variables exported for the command, passed in the environment (see Environment)
• traps caught by the shell are reset to the values inherited from the shell's parent, and traps ignored by the shell are ignored

A command invoked in this separate environment cannot affect the shell's execution environment.

Command substitution and asynchronous commands are invoked in a subshell environment that is a duplicate of the shell environment, except that traps caught by the shell are reset to the values that the shell inherited from its parent at invocation. Builtin commands that are invoked as part of a pipeline are also executed in a subshell environment. Changes made to the subshell environment cannot affect the shell's execution environment.

Environment

On invocation, the shell marks each parameter export to child processes.
Executed commands inherit the environment. unset, export and declare add/delete parameters and functions to/from the environment.

The environment for any simple command or function may be augmented temporarily by prefixing it with parameter assignments, as described in Shell Parameters. These assignment statements affect only the environment seen by that command.

With -k (The Set Builtin), then all parameter assignments are placed in the environment for a command, not just those that precede the command name.

When Bash invokes an external command, the variable $_ is set to the full path name of the command and is included in the environment.

Exit Status

The exit status is used by the Conditional Constructs and some of the list constructs .

All builtins return an exit status of 2 to indicate incorrect usage.

Signals

If BASH receives a signal, for which a trap has been set, while waiting for a command to complete, the trap will not be executed until the command completes.
If waiting for an asynchronus command an exit status greater than 128 is set, then trap is executed.

Commands started by Bash have signal handlers set to the values inherited by the shell from its parent.

Shell Scripts

The special parameter $0 is set to the name of the file (rather than the name of the shell), and the positional parameters are set to the remaining arguments.

When Bash finds such a file in the $PATH for a command, it spawns a subshell to execute it. In other words, executing

filename arguments

bash filename arguments

This subshell initializes itself, so that the effect is as if a new shell had been invoked to interpret the script, with the exception that the locations of commands remembered by the parent (see the description of hash in Bourne Shell Builtins) are retained by the child.

If the first line of a script begins with #!, the remainder of the line specifies an interpreter for the the script, followed by the arguments.
A shell script must executable (see chmod +x )