from www.gnu.org/software/bash/manual/bashref.html
Edition 4.1, last updated 23 December 2009
This document is based on Edition 2.5b, last updated 15 July 2002, of The GNU Bash Reference Manual, for Bash, Version 2.05b.

references to zsh are included because
Apple/Mac OS no longer supports bash!

^Z Indicates different from zsh
^Ź Indicates not in zsh

options

help	echo arrays
if	test	do / done	while until	break / exit	continue	return [`n`]	case / esac
select	trap
eval	exec
declare	export	readonly	local	hash	history	fc
let	alias / unalias	bind	printf
read	readarray mapfile
getopts	shift	shopt^Ź	set / unset
source	times	time	type
builtin	command	enable	ulimit	umask	typeset	logout
directory
cd	pwd	popd / pushd	dirs
job control
bg / fg	jobs	disown	kill	wait	suspend

Bash Builtin Commands

Builtin commands maybe superceeded by files in /bin which may have additional options or features.

> ls  /bin  
 [ 
cat       mv        rm          cp        ls       ed     mkdir     rmdir     link   ln   unlink    
chmod     sync      pwd         realpath  dd       date   expr      stty      wait4path
hostname  ps        test        df         sleep   pax    echo      kill      launchctl    
bash      dash      ksh         tcsh       sh      zsh

Commands marked "No**" under External exist externally implemented as scripts using a builtin command of the same name.

 Command   External   csh          sh   
  !            No      No           Yes
  %            No      Yes          No
  .            No      No           Yes
  :            No      Yes          Yes
  @            No      Yes          Yes
  [            Yes     No           Yes
  {            No      No           Yes
  }            No      No           Yes
  alias        No**    Yes          Yes
  alloc        No      Yes          No
  bg           No**    Yes          Yes
  bind         No      No           Yes
  bindkey      No      Yes          No
  break        No      Yes          Yes
  breaksw      No      Yes          No
  builtin      No      No           Yes
  builtins     No      Yes          No
  case         No      Yes          Yes
  cd           No**    Yes          Yes
  chdir        No      Yes          Yes
  command      No**    No           Yes
  complete     No      Yes          No
  continue     No      Yes          Yes
  default      No      Yes          No
  dirs         No      Yes          No
  do           No      No           Yes
  done         No      No           Yes
  echo         Yes     Yes          Yes
  echotc       No      Yes          No
  elif         No      No           Yes
  else         No      Yes          Yes
  end          No      Yes          No
  endif        No      Yes          No
  endsw        No      Yes          No
  esac         No      No           Yes
  eval         No      Yes          Yes
  exec         No      Yes          Yes
  exit         No      Yes          Yes
  export       No      No           Yes
  false        Yes     No           Yes
  fc           No**    No           Yes
  fg           No**    Yes          Yes
  filetest     No      Yes          No
  fi           No      No           Yes
  for          No      No           Yes
  foreach      No      Yes          No
  getopts      No**    No           Yes
  glob         No      Yes          No
  goto         No      Yes          No
  hash         No**    No           Yes
  hashstat     No      Yes          No
  history      No      Yes          No
  hup          No      Yes          No
  if           No      Yes          Yes

  Command   External   csh          sh   
  jobid        No      No           Yes
  jobs         No**    Yes          Yes
  kill         Yes     Yes          Yes
  limit        No      Yes          No
  local        No      No           Yes
  log          No      Yes          No
  login        Yes     Yes          No
  logout       No      Yes          No
  ls-F         No      Yes          No
  nice         Yes     Yes          No
  nohup        Yes     Yes          No
  notify       No      Yes          No
  onintr       No      Yes          No
  popd         No      Yes          No
  printenv     Yes     Yes          No
  printf       Yes     No           Yes
  pushd        No      Yes          No
  pwd          Yes     No           Yes
  read         No**    No           Yes
  readonly     No      No           Yes
  rehash       No      Yes          No
  repeat       No      Yes          No
  return       No      No           Yes
  sched        No      Yes          No
  set          No      Yes          Yes
  setenv       No      Yes          No
  settc        No      Yes          No
  setty        No      Yes          No
  setvar       No      No           Yes
  shift        No      Yes          Yes
  source       No      Yes          No
  stop         No      Yes          No
  suspend      No      Yes          No
  switch       No      Yes          No
  telltc       No      Yes          No
  test         Yes     No           Yes
  then         No      No           Yes
  time         Yes     Yes          No
  times        No      No           Yes
  trap         No      No           Yes
  true         Yes     No           Yes
  type         No**    No           Yes
  ulimit       No**    No           Yes
  umask        No**    Yes          Yes
  unalias      No**    Yes          Yes
  uncomplete   No      Yes          No
  unhash       No      Yes          No
  unlimit      No      Yes          No
  unset        No      Yes          Yes
  unsetenv     No      Yes          No
  until        No      No           Yes
  wait         No**    Yes          Yes
  where        No      Yes          No
  which        Yes     Yes          No
  while        No      Yes          Yes

 % which kill
kill: shell built-in command
 % ls -l /bin/kill
101584 Nov  1 01:31 /bin/kill*

% which echo echo: shell built-in command dgerman@smac14 docs % ls -l /bin/echo 101184 Nov 1 01:31 /bin/echo*

: [`arguments`]

Expand arguments and perform redirections.
The return status is 0.

.^† `cmdfile` aka source `cmdfile`

The "dot" (aka source) executes commands from cmdfile in the current shell context as if there were included in the command stream.
Variables created or modified by the script remain available.
If cmdfile does not contain a slash, $PATH is searched.
Requires read permission to filename, does not need eXexute permission .
The return status is the exit status of the last command executed, or 0 if no commands are executed.
If cmdfile cannot be read, the return status is 127.

alias [-p] `name`=`value` [`name`=`value`…

Aliases provide a substitute for first word of a command. If the last character of value is a [space] or [tab] the next command word is also checked for alias expansion.
Exampe: alias ls="ls -F" causes a subsequent ls to include suffixes.

name may include metacharacters^† except =, value may include metacharacters.

Output aliases on standard output when used without arguments or with -p.

aliases are not expanded in scripts without set expand_aliases=on.
Examples:

alias c='cp --preserve --interactive'
alias cd-='cd -'
alias cd..='cd ..'
alias chdir='cd'
alias ci='vi'

alias del='rm'
alias edit='vi'
alias g='grep'
alias h='head -$LINES'
alias l.='ls -d . --color=tty'
alias ls-l='/bin/ls -l'

alias mv='mv --interactive'
alias t='tail -$LINES'
alias vi='vim'
alias which='type -path'

Aliases are not expanded when the shell is not interactive (i.e. in a script!), unless expand_aliases is set.

An alias definition on the same line as another command do not take effect until the next line.
Aliases are expanded when a function definition is read, not when the function is executed. As a consequence, aliases defined in a function are not available until after that function is executed.

To be safe, put alias definitions on a separate line, and do not use alias in compound commands.

Consider assigning an $environmentVariable to the full-path program and then use that. For Example:

> nrfjprog='/Applications/Nordic Semiconductor/nrfjprog/nrfjprog'
> "$nrfjprog" --memrd 0x10000100 # quotes here mitigate the problem of the directory containing and embedded space.

If arguments are needed, a shell function should be used.

unalias [-a] [`alias_name` … ]

Removes alias_names. -a all.

bind

bind [-m keymap] [-lpsvPSV]
bind [-m keymap] [-q function] [-u function] [-r keyseq]
bind [-m keymap] -f filename
bind [-m keymap] keyseq:function-name

Display current readline key and function bindings, or bind a key sequence to a readline function or macro.
The syntax is as with .inputrc readline init file.
Where emacs is the command line editor, Each binding must be passed as a separate argument in emacs format where \C-x is control X and \M-x is ␛x

use "\C-x\C-r":re-read-init-file. hold the [ctrl] key and press xr

If vi is the command line editor ( set -o vi ) when the line has been recalled using ␛k, bindings as set per vi command mode.
For example to Apppend to the recalled line press an A .

Troublesome key-bindings which cause problems on various keyboards/telnet clients include:
C-? which is sometimes transmitted when the [del] key is pressed.
\C-?: backward-delete-char

break [`n`]

Exit from a for, while, until, or select loop.
If n is supplied, the nth enclosing loop is exited. n must be greater than or equal to 1.
The return status is 0 unless n is not greater than or equal to 1.

builtin [`shell-builtin` [`args`]]

Useful when defining a shell function with the same name as a shell-builtin, retaining the functionality of the builtin within the function.
The return status is non-zero if shell-builtin is not a shell-builtin command.

command [-pVv] `command` [`arguments` …]

Runs command with arguments ignoring any function named command.
Only builtin commands or commands found by searching the PATH are executed.

For example: a function named ls, which includes command ls within the function, will execute the external command ls instead of calling the function recursively.

-p Use default for $PATH that is guaranteed to find all of the standard utilities.
The return status is 127 if command cannot be found, an error occurred or
the exit status of the command .
-v Display the command or file name used to invoke command
-V Produces a more verbose description, the return status is 0 if command is found.

> command -v make
/usr/bin/make
> command -V make
make is hashed (/usr/bin/make)
> which make
/usr/bin/make
> which which 
> command -V which
which is aliased to `type -path'

cd [-LP] [`directory`]

When files are referenced, the "current directory" is where they are expected to be found.
Specify the path to locate files in another directory, for example ls /home/myname/webProject/index.html.
Change the current directory with cd if frequent access to another directory is needed.
For example: cd /home/myname/webProject

`cd`	without a directory changes to `$HOME`.
`cd -`	changes to the previous directory. `$OLDPWD`.

To have cd use the environment variable specified as directory set the sopt cdable_vars.
For example (perhaps in a .profile): export docs=/home/myname/docs
cd docs changes current working directory to /home/myname/docs
if the current directory was /home/myname/source/
and /home/myhome/source/docs doesn't exist,

To cause bash to correct minor spellings in the new current directory use shopt -s cdspell
^Ź

If $CDPATH exists, it is used as a search path.
If directory begins with a slash, CDPATH is not used.
i.e. cd /home/myname/dox changes current working directory to /home/myname/dox.
-L follow symbolic links, default (see ln)
-P Prevent symbolic links from being followed.
The return status is 0 if the directory is successfully changed, non-zero otherwise. i.e. 1

See dirs popd pushd

continue [`n`]

Resume the next iteration of an enclosing for, while, until, or select loop.
If n is supplied, the execution of the nth enclosing loop is resumed. n must be greater than or equal to 1.
The return status is 0 unless n is not greater than or equal to 1.

top

declare [-p | -afFrtxi] [`name`[=`value`]]

Declare variables and give them attributes. If no names are given, the values of variables are displayed.

`-pa`	Variable names, attributes and values are displayed.
`-F`	Function names and attributes are displayed.
`-f`	Only functions are displayed. > declare -f quote quote () { local quoted=${1//\'/\'\\\'\'}; printf "'%s'" "$quoted" }

`-a`	array variable (Arrays).
`-A`	Associative array is created. Not 
`-i`	integer; arithmetic evaluation (Shell Arithmetic) is performed when the variable is assigned a value.
`-r`	readonly, cannot be set again or unset.
`-t`	Give function the trace attribute which inherit `DEBUG` and `RETURN` traps from the calling shell.
`-x`	export

> declare -p UID
declare -ir UID="501"    integer; readonly

> declare -f
update_terminal_cwd () 
{ 
    local SEARCH=' ';
    local REPLACE='%20';
    local PWD_URL="file://$HOSTNAME${PWD//$SEARCH/$REPLACE}";
    printf '\e]7;%s\a' "$PWD_URL"
}

> declare -F
declare -f update_terminal_cwd

Use + instead of - to turn off^sic the attribute .
Used in a function, makes each name local, as with local

An invalid option is encountered,
One of names is not a valid shell variable name
An attempt to define a function using -f foo=bar
Assign a value to an array variable without using the compound assignment syntax (Arrays)
Turn off array status for an array variable
Assign a value to a readonly variable
Turn off readonly status for a readonly variable
Display a non-existent function with -f.

echo [-n[e|E] [`args` …]

There is a command /bin/echo and there is printf

Output args separated by spaces, terminated with a newline.

`-n`	no newline output (NOT zsh use /bin/echo)
`-e`	enable the interpretation of the special character codes.
`-E`	no Enabling " … (default!)

`\a` alert (bell)	`\b` backspace	`\\` backslash
`\f` form feed	`\n` new line	`\r` carriage return	`\t` horizontal tab	`\v` vertical tab
`\e` escape	`\c` suppress trailing newline
`\nnn` the character whose `ASCII` code is the octal value `nnn` (1 to 3 digits) `\xnnn` the character whose `ASCII` code is the hexadecimal value `nnn` (1 to 3 digits)

Readline will already have processed the backslash so you really need to use \\a … with -e
Hash # begins a comment and stops the echo string,
Environment variables or arg index are prefixed with $ as usual.

enable [-n] [-p] [-f `filename`] [-ads] [`name` …]

-n disable builtin shell command. allowing a file command with that name without specifying a full pathname.
To create a script called test first

 enable -n test # i.e. disable the builtin test command

This will most likely confuse you later! ed

With no options enable the builtin.

-p print no options or no name arguments : a list all of the builtins(like 61 of them) .
all are enable:

enable|column
 .       caller     disown      fc      let     readonly    times     unset
 :       cd         echo        fg      local   return      trap      wait
 [       command    getopts     logout  set     true
 alias   compgen    eval        hash    popd    shift       type
 bg      complete   exec        help    printf  shopt^Ź        typeset
 bind    continue   exit        history pushd   source      ulimit
 break   declare    export      jobs    pwd     suspend     umask
 builtin dirs       false       kill    read    test        unalias

-a list all builtins status.
Example:

% enable -a
enable . enable : enable [ enable alias" …
bg bind break builtin caller cd command compgen complete continue declare dirs disown echo enable eval exec exit export false fc fg getopts hash help history jobs kill let local logout popd printf pushd pwd read readonly return set shift shopt ^Ź source suspend test times trap true type typeset ulimit umask unalias unset wait

-f Load the new builtin command name from shared object filename, on systems that support dynamic loading.
-d Delete a builtin loaded with -f.
-s restricts enable to the POSIX special builtins.

% enable -ps enable . enable : enable break" …
continue eval exec exit export readonly return set shift source times trap unset

If -s^† is used with -f, the new builtin becomes a special builtin.
The return status is 0 unless a name is not a shell builtin or there is an error loading a new builtin from a shared object.

eval [`arguments`]

The arguments are concatenated into a single command, which is read and executed. Its exit status is returned as the exit status of eval.
If there are no arguments or only empty arguments, the return status is 0.

exec [-cl] [-a `name`] [`command` [`arguments`]]

If command is supplied, it replaces the shell without creating a new process.
-c causes command to be executed with an empty (clear) environment.
-l as if the login program, the shell passes - as the zeroth arg to command.
-a the shell passes name as the zeroth argument to command.
If no command is specified, redirections may be used to affect the current shell environment.
If there are no redirection errors, the return status is 0̸; otherwise non-zero.

exit [`n`]

Exits to the caller of a script with a status of mod(n,256) (default 0) which can be examined as $?
Example:

parent childscript.sh
childScript.sh
ES=$? if [ $ES -ne 0 ] then echo "## childScript failed ES= $ES, I quit too!"; exit $ES fi
… more parent stuff executed if childscript.sh went well.

various commands exit 4

Any trap on EXIT is executed before the shell terminates.

return returns from a function.

export [-fn] [-p] [`name`[=`value`]] …

Mark each name so it is passed to child processes in the environment.
The child process cannot modify the values of names

-f name is function; otherwise the names refer to variables.
-n no longer mark each name for export.
-p output in a form that may be reused as input.
If no names are supplied the list of exported names is displayed.

> export
declare -x EDITOR="vi"
declare -x EXINIT="set showmode ignorecase ruler tabstop=4 mesg verbose exrc"
declare -x HOME="/home2/realge"
declare -x HOSTNAME="slmp-550-13.slc.westdc.net"
declare -x INPUTRC^†
declare -x LANG="en_US.UTF-8"
declare -x LC_ALL="en_US.UTF-8"
declare -x LINES="40"
declare -x LOGNAME="reer1"
declare -x MAIL="/var/spool/mail/realg"
declare -x OLDPWD="/home2/realg"
declare -x PAGER="less"
declare -x PATH="/usr/local/bin:/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/usr/libexec"
declare -x PS1="\$PWD > "
declare -x PWD="/home2/reer1/www"
declare -x SHELL="/usr/local/cpanel/bin/jailshell"
declare -x SHLVL="1"
declare -x TERM="xterm-256color"
declare -x TZ="US/Eastern"
declare -x USER="realge"
declare -x VISUAL="vi"

Return status is 0 unless an invalid option is supplied, one of the names is not a valid shell variable name or -f is supplied with a name that is not a shell function.

See also set
These environment variables in a parent (login shell) do not have the same values in the child .

$COLORS $DIRSTACK ~/www $DNS $HISTFILE /Volumes/DATA/userna/.bash_history $HISTFILESIZE 1000 $INPUTRC $LIMITUSER $LOCALLIBUSER $MAILCHECK 60 $OSTYPE linux-gnu $PPID 508521 $SHELLOPTS braceexpand:hashall:interactive-comments consoletype tmpid whoami

getopts `optstring` `name` [`args`]

Parses positional parameters.
Ex: getopts qbvVd: options

optstring are the option letters to be recognized;
A letter followed by a colon the option is expected to have an argument, which should be separated from it by white space.
Each time invoked, getopts places the next option in the shell variable name, initializing name if it does not exist, and the index of the next argument to be processed into the variable

OPTIND is initialized to 1 each time the shell or a shell script is invoked.
When an option has an argument, OPTARG is set to the argument.
OPTIND must be manually reset between multiple calls to getopts within the same shell invocation if a new set of parameters is to be used.
When the end of options is encountered, getopts exits with a return value greater than 0.
OPTIND is set to the index of the first non-option argument, and name is set to ?.
getopts normally parses the positional parameters, but if more arguments are given in args, those are parsed instead.
Errors are reported .

If the first character of optstring is a colon, silent error reporting is used.
In normal operation diagnostic messages are displayed when invalid options or missing option arguments are encountered.
If the variable OPTERR is set to 0, no error messages will be displayed, even if the first character of optstring is not a colon.
If an invalid option is seen, getopts places ? into name and, if not silent, prints an error message and unsets OPTARG.
If getopts is silent, the option character found is placed in OPTARG and no diagnostic message is displayed.
If a required argument is not found, and getopts is not silent, a question mark (?) is placed in name, OPTARG is unset, and a diagnostic message is displayed.
If getopts is silent, a : is placed in name and OPTARG is set to the option character found.

variables used:
OPTERR if 0 supress error display.
name
OPTIND set to index of first non-otion arg OPTARG set to arg of name set to ? optstring

hash [-r] [-p `filename`] [`command`]

Find command in $PATH and remember the full pathname to avoiding searching on subsequent usages. See checkhash
-p filename is the location of command, don't search $PATH.
-r reset

If no arguments are given, information about remembered commands is displayed.

 hits command
   1    /home2/reer1/.bin/df
   1    /home2/reer1/.bin/du
  10    /usr/bin/vim
   1    /home2/reer1/.bin/stat
   1    /home2/reer1/.bin/mysql

The return status is 0 unless a name is not found or an invalid option is supplied.

If command is deleted confusion will result unless shopt checkhash is set.

help [`pattern`]

Display information about builtin commands.
With pattern dispilays detailed help on all commands matching.

Without pattern builtins are listed.

GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin15)
These shell commands are defined internally.  Type `help' to see this list.
Use help name to find out more about the function name.
Use info bash to find out more about the shell in general.
Use man -k or info to find out more about commands not in this list.

A star (*) next to a name means that the command is disabled.

 JOB_SPEC [&]                       (( expression ))
 . filename [arguments]             :
 [ arg... ]                         [[ expression ]]
 alias [-p] [name[=value] ... ]     bg [job_spec ...]
 bind [-lpvsPVS] [-m keymap] [-f fi break [n]
 builtin [shell-builtin [arg ...]]  caller [EXPR]
 case WORD in [PATTERN [| PATTERN]. cd [-L|-P] [dir]
 command [-pVv] command [arg ...]   compgen [-abcdefgjksuv] [-o option
 complete [-abcdefgjksuv] [-pr] [-o continue [n]
 declare [-afFirtx] [-p] [name[=val dirs [-clpv] [+N] [-N]
 disown [-h] [-ar] [jobspec ...]    echo [-neE] [arg ...]
 enable [-pnds] [-a] [-f filename]  eval [arg ...]
 exec [-cl] [-a name] file [redirec exit [n]
 export [-nf] [name[=value] ...] or false
 fc [-e ename] [-nlr] [first] [last fg [job_spec]
 for NAME [in WORDS ... ;] do COMMA for (( exp1; exp2; exp3 )); do COM
 function NAME { COMMANDS ; } or NA getopts optstring name [arg]
 hash [-lr] [-p pathname] [-dt] [na help [-s] [pattern ...]
 history [-c] [-d offset] [n] or hi if COMMANDS; then COMMANDS; [ elif
 jobs [-lnprs] [jobspec ...] or job kill [-s sigspec | -n signum | -si
 let arg [arg ...]                  local name[=value] ...
 logout                             popd [+N | -N] [-n]
 printf [-v var] format [arguments] pushd [dir | +N | -N] [-n]
 pwd [-LP]                          read [-ers] [-u fd] [-t timeout] [
 readonly [-af] [name[=value] ...]  return [n]
 select NAME [in WORDS ... ;] do CO set [--abefhkmnptuvxBCHP] [-o opti
 shift [n]                          shopt^Ź  [-pqsu] [-o long-option] opt
 source filename [arguments]        suspend [-f]
 test [expr]                        time [-p] PIPELINE
 times                              trap [-lp] [arg signal_spec ...]
 true                               type [-afptP] name [name ...]
 typeset [-afFirtx] [-p] name[=valu ulimit [-SHacdfilmnpqstuvx] [limit
 umask [-p] [-S] [mode]             unalias [-a] name [name ...]
 unset [-f] [-v] [name ...]         until COMMANDS; do COMMANDS; done
 variables - Some variable names an wait [n]
 while COMMANDS; do COMMANDS; done  { COMMANDS ; }

if a match is displayed the return status is 0
If no command matches: +++

-bash: help: no help topics match pattern  Try help help or man -k pattern or info pattern.
echo $?
1

let `expression` [`expression`]

Allows arithmetic to be performed on shell variables.
Each expression is evaluated according to the rules given in Shell Arithmetic.
If the last expression evaluates to 0, let returns 1 ^sic.
Each ARG is an arithmetic expression to be evaluated in fixed-width integers with no check for overflow. Division by 0 is trapped and flagged as an error.
% let j=3/0
zsh: division by zero
bash: let: j=3/0: division by 0 (error token is "0")

Operators are grouped in levels of equal-precedence , levels are listed in of decreasing precedence.

`id++ , id--`	post-increment , post-decrement
`++id , --id`	pre-increment , pre-decrement
`- , +`	unary minus , plus
`! , ~`	logical and bitwise negation
	exponentiation
`, / , %`	multiplication , division , remainder
`+ , -`	addition , subtraction
`<< >>`	left and right bitwise shifts
`<= , >= , < , >`	comparison
`== , !=`	equality , inequality
`& , \| , ^`	bitwise AND, OR, XOR
`&& , \|\|`	logical AND, OR
`expr ? expr : expr`	conditional operator
`= , *= , /= , %= , += , -= , <<= , >>= , &= , ^= , \|=`	assignment

Shell variables are allowed as operands. The name of the variable is replaced by its value (coerced to a fixed-width integer) within an expression. The variable does not need to have integer attribute.
Operators are evaluated in order of precedence. Sub-expressions in parentheses are evaluated first and override the precedence rules above.
If the last ARG evaluates to 0, let returns 1^sic; 0 is returned otherwise.

mmdd=`date +%m%d`
> echo $mmdd
1231
> m=$mmdd-1           # no space is permitted after  the =
> echo $m
1231-1
> let x=$mmdd-1
> echo $x
1230

> n= 31
-bash: 31: command not found

(_) how to handle Jaunuary date? ie January 2011 does : 1101 - 1 = 1100 ; not the desired 1012 i.e. december 2010

local `name`[=`value`]…

Within a function, for each argument, local variable, name, is created, and assigned value.
The scope is restricted to that function and its children.
return status is 0 unless used outside a function or an invalid name is supplied returns 1 .

funct(){
    + local a=1
    + echo $a
    + }
>funct
1
>echo $a
>

logout[`n`]

Exit a login shell, returning a status of n shell's parent.

printf `format` [`arguments`]

Not to be confused with the printf utility!

Write arguments to standard output under control of format, a string which contains :

character escape sequences (for example \n) converted and copied to standard output
format specifications, (prefixed with % ) which output the next argument
plain characters copied to standard output

In addition to the printf(1) formats, %b expands backslash escape sequences in the corresponding argument and
%q outputs the corresponding argument in a format that can be used as shell input.
The format is reused as necessary to process all arguments.
If the format specifies more arguments than are supplied, the extra format specifications behave as if a 0 or null string had been supplied.

pwd [-LP]

Display the current working directory.
-P will not contain symbolic links.
-L may contain symbolic links.
The return status is 0 unless an error is encountered while determining the name of the current directory or an invalid option is supplied.

return [`n`]

Used by functions to continue execution after the calling statment, with the optional return value n.
May be used to terminate execution of a script being executed with the .^† builtin, returning either n or the exit status of the last command executed within the script as the exit status of the script.
The return status is false if return is used outside a function and not during the execution of a script by .^† .

exit is for scripts.

read

shell builtin as well as /usr/bin/read builtin `echo ${0##*/} | tr \[:upper:] \[:lower:]` ${1+"$@"} shows lowercase caller ??

read [-p prompt] [-er] [-a aname] [name … ]

One line is read from the standard input.
The characters in IFS^†. (default: IFS=$' \t\n\C-@' i.e tab, newLine and null (Viewed using set |grep IFS |head -n 1) are used to split the line into words.
  The first word is assigned to the first $aname, the second word to the second $aname, …
  leftover words and their intervening separators assigned to the last name.
  If there are fewer words than names, the remaining names are assigned empty values.
  If no names are supplied, the line is assigned to $REPLY with tabs replaced by a single space.

`-p prompt`	Display `prompt,` before reading input, if input is coming from a terminal.
`-e`	Readline is used to obtain the line. (a good thing)
`-a aname`	words input are assigned to sequential indices of the array variable (NOT `zsh` `aname`, starting at 0. All elements are removed from `aname` before the assignment. Other `aname` arguments are ignored.
`-r`	a backslash-newline pair is not ignored, and the backslash is considered to be part of the line.
`-k n`	zsh `read "REPLY? Enter a single characer" -k 1`

 % read -a aarryy 
xxxxx yy zzzzz

% set |grep xxxx
aarryy=([0]="xxxxx" [1]="yy" [2]="zzzzz")
% echo $arry[0]
xxxxx[0] 

% read -k 1 "REPLY?Press any key to continue: "
Press any key to continue: 1%      # I tried to enter 123. read took the 1 and left the 2and 3 for bash.
M% 23

The return code is
0 OK or
1 end-of-file was encountered.

Zsh's read command has several options which differ from the Bash implementation.

read "response?continue" Keywords: response?, password?, choice?

Displays % when input is complete.

PS1=')'
)read -q  ans
y%
)

-q $vv  Query, for yes/no questions. reads a single key, sets the variable to y if 'y' or 'Y' and n otherwise. 

Echo is supressed.

-r  raw mode, supresses backslash interpretation.
-k [num] key  Reads num characters, 

including return and other special characters, other than ^m (aka return), ^s, ^q  and ^c which causes read to exit with return code of 130.

 The variable $key is assigned the characters read.

Default: 1 character is read from the terminal, Not standard input which discards piping.% read -k 9 redded     
123456789%/bin/echo -n $redded |hexdump -C
0000  31 32 33 34 35 36 37 38  0a           |12345678.|
% read -k 9 redded  
1tab2tab8backspace3backspace3 no return was entered!
% /bin/echo -n $redded |hexdump -C
0000  31 09 32 09 38 7f 33 7f  7f                       |1.2.8.3..|
% read -k 9 redded                
123return
return
return
return
return
return
% /bin/echo -n $redded |hexdump -C
0000  31 32 33 0a 0a 0a 0a 0a  0a                       |123......|
% read -k 9 redded
1^\2return
^C%
% /bin/echo -n $redded |hexdump -C
0000  31 32 0a                                          |12.|
% ls -l |read -k 9 redded -u 0   
123456789% /bin/echo -n $redded |hexdump -C
0000  31 32 33 34 35 36 37 38  39 0a               |123456789.|  output from ls is lost. 

-u [n]  Reads from file unit n (descriptor). 
    Use -u 0 to read from standard input, important when using option -k in pipelines.

-s  Silent, echo is supressed if reading from the terminal (useful for passwords).

-A  Reads the input into array, using IFS (Internal Field Separator) to split the line into elements. Note Zsh arrays are 1-indexed . 





linux read  command has several options many of which differ from the Bash implementation. 


read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]

readarray|mapfile

readarrray [-n count]  [-O origin]  
[-s count]  [-t]  
[-u file]  [-C callback]  
[-c quantum]  [array]

wiki.bash-hackers.org

Read lines from the standard input (or file) into the indexed array variable array, . mapfile is the default array.
returns success (0) unless an invalid option is given or the array is readonly.

`-c quantum`	number of lines that have to be read between calls to the `callback`. The default 5000 !
`-C callback`	shell code. Outputs the index of the array that will be assigned, and the line is appended at evaluation time.
`-n count`	maximun number of lines, Default 0, all.
`-O origin`	Starts populating the array at `origin` rather than clearing it and starting at index 0.
`-s count`	skips `count` lines.
`-t`	Trailing newline s are removed
`-u file`	rather than standard input.

readonly [-apf] [`name`] …

Mark each name as readonly, the values may not be changed by subsequent assignment.
-f each name refers to a shell function.
-a each name refers to an array variable.
If no arguments are given, or if -p is supplied, a list of all readonly names is displayed.
-p display in a format that may be reused as input.

The return status is 0 unless an invalid option is supplied, one of the name arguments is not a valid shell variable or function name, or the -f option is supplied with a name that is not a shell function.

set [--abefhkmnptuvxBCHP] [-o `option`] [`argument` …]

sets name to value. Not in zsh

Without options, displays names and values of variables and functions (with their definition which can be lenghty) or resetting the currently-set variables. Read-only variables cannot be reset. In posix mode, only shell variables are listed. The output is sorted according to the current locale. When options are specified, they set or unset shell attributes.
Any arguments remaining after the options are processed are treated as values for the positional parameters and are assigned, in order, to $1, $2, ... $n.

Caution, variable $_ may be very long so this is useful: set | cut -c1-60|more

BASH=/bin/bash
BASH_ARGC=()
BASH_ARGV=()
BASH_LINENO=()
BASH_REMATCH=([0]="n")
BASH_SOURCE=()
BASH_VERSINFO=([0]="3" [1]="2" [2]="57" [3]="1" [4]="release" [5]="x86_64-apple-darwin15")
BASH_VERSION='3.2.57(1)-release'
BLOCKSIZE=1k
COLUMNS=140
DIRSTACK=([0]="~" [1]="/Volumes/homes/sams/Documents/computerstuff/firmware" [2]="/Volumes/DATA/homes/sams/bin") 
EUID=531
…
GROUPS=()
…
HOME=/Users/samspade
…
HOSTNAME=venus
HOSTTYPE=x86_64
IFS=$' \t\n'
LANG=en_US.UTF-8
LC_ALL=C
… … …

export attribute.

-e

errexit

Exit immediately if a pipeline, ( which may consist of a single simple command, list , or a compound command ) returns a non-zero status.

Does not exit if command list follows a
while ,
until ,
part of the test in an if statement,
part of any command executed in a && or || list, except the command following the final && or ||any command in a pipeline but the last, or
if the commands return status is being inverted with !.
If a compound command other than a subshell returns a non-zero status because a command failed while -e was being ignored,
the shell does not exit.

A trap on ERR is executed before the shell exits. This applies to the shell environment and each subshell environment separately (see Command Execution Environment), and may cause subshells to exit before executing all the commands in the subshell.

If a compound command or shell function executes, in a context where -e is being ignored, none of the commands executed within the compound command or function body will be affected by the -e setting,

If a compound command or shell function sets -e while executing in a context where -e is ignored, that setting will not have any effect until the compound command or the command containing the function call completes.

-o

option-name % echo $- ( Special parameter to display option flags)
himBH (ie hashall, shellIsInteractive , monitor, Braceexpand histexpand )

Using + causes these options to be turned off^sic.

> set -o

allexport off
braceexpand on
emacs off
errexit off
errtrace off
functrace off
hashall on
histexpand on
history on

ignoreeof off
interactive-comments on
keyword off
noclobber off
noexec off
noglob off
nolog off
notify off

monitor on
nounset off
onecmd off
physical off
pipefail off
posix off
privileged off
verbose off
vi on
xtrace off

Set the option corresponding to option-name:

set -o option-name [on| off ] Set the option corresponding to option-name

flag -o name

-a allexport Mark variables which are modified or created for export.

-b notify Terminated background jobs notify status immediately, rather than before displaying the next primary prompt.

-e

errexit

Exit immediately if

a Simple Command exits with a non-zero status, unless
- while or until loop
- if statement
- && or || list
if the command's return status is being inverted using !.

-f noglob file name generation (globbing) is disabled.

-h hashall Locate and remember (hash) commands as they are looked up for execution. default: enabled .

-k keyword Keyword=value format arguments are placed in the environment , not just those that precede the command name.

-m monitor Job control is enabled (Job Control).

-n noexec Read commands but do not execute them
Check a script for syntax errors , -v helpful. Ignored if interactive .

emacs Use emacs-style line editing interface (see readline).

vi

Use a vi-style line editing interface.

 > set -o vi

history Enable command history.

-H histexpand Enable ! style history substitution (History Expansion). Default on for interactive shells.

-p privileged Turn on privileged mode.

ignoreeof An interactive shell will not exit upon reading EOF.

posix

POSIX Mode

$BASH_ENV and $ENV files are skipped.
shell functions are not inherited from the environment, and the
SHELLOPTS is ignored.
Enabled on startup if effective user/group ID is not real user/group ID.
Turning this option off sets the effective user and group ids to the real user and group ids.

-t onecmd Exit after reading and executing one command.

-u nounset Treat unset variables as an error when performing parameter expansion.
An error message will be written to the standard error, and a non-interactive shell will exit.

-v

verbose

display input lines as they are read.

 > sh -v myscript.sh NWregion.trn SWregion.trn
collectTransactions <  $1
2,342 updates, 3 deletes, 393 adds.
collectTransactions <  $2
3,937 updates, 9 deletes, 42 adds.
GenerateSummary > summary.rpt

-x

xtrace

execution trace of simple , for, case and select commands.
$PS4 (default +), the command and the expanded arguments are displayed before the command is executed .

 > sh -x myscript.sh  NWregion.trn SWregion.trn
+collectTransactions <  NWregion.trn
2,342 updates, 3 deletes, 393 adds.
+collectTransactions <  SWregion.trn
3,937 updates, 9 deletes, 42 adds.
+GenerateSummary > summary.rpt

-B braceexpand bash will perform Brace expansion Default on.

-C noclobber Con Cat output; redirections using >, >&, and <> won't clobber files.

-P

physical

If set, The Physical directory is used instead of followng symbolic links when performing commands such as

cd

which change the current directory. By default, Bash follows the logical chain of directories when performing commands which change the current directory.
For example, if /usr/sys is a symbolic link to /usr/local/sys then:

default

$ cd /usr/sys; echo $PWD
/usr/sys
$ cd ..; pwd
/usr

If set -P is on, then:

$ cd /usr/sys; echo $PWD
/usr/local/sys
$ cd ..; pwd
/usr/local

-- If no arguments follow --, positional parameters are unset.
Otherwise, the positional parameters are set to the arguments, even if some of them begin with a -.

- Signals the end of options, remaining arguments to be assigned to the positional parameters.
-x and -v are turned off.
If there are no arguments, the positional parameters remain unchanged.

example: (1223)

See : shopt, bash variables,invoking bash.

`-B`	`braceexpand`
	`emacs`	Use an emacs-style line editing interface (see Command Line Editing). This also affects the editing interface used for `read -e`
`-E`	`errtrace`
`-T`	`functrace`
`-H`	`histexpand`
`-C`	`noclobber`
`-P`	`physical`
	`ignoreeof`	An interactive shell will not exit upon reading EOF ( i.e. `^d`
	`history`	Enable command history . on by default in interactive shells
	`pipefail`	The return value of a pipeline is the value of the last (rightmost) command to exit with a non-zero status, or zero if all commands in the pipeline exit successfully. Disabled by default
	`posix`	Set Bash to match the standard (see Bash POSIX Mode).
-v	`verbose`
	`vi`	Use `vi`-style command line editing and `read -e`
`-p`	`privileged`	Turn on^sic privileged mode. `$BASH_ENV` and `$ENV` files are not processed, Shell functions are not inherited from the environment, and `$SHELLOPTS, $BASHOPTS, $CDPATH and $GLOBIGNORE` are ignored. If `-p` is supplied at startup, the effective user id is not reset. Turning this off causes the effective user and group ids to be set to the real user and group ids.
`-r`		Enable restricted shell mode. Cannot be unset
`-t`	`onecmd`	Exit after reading and executing one command.
`-u`	`nounset`	Treat unset variables and parameters as an error when performing parameter expansion. An error message will be written to the standard error and a non-interactive shell will exit. Except the special parameters `@` or ``, or array variables subscripted with `@` or ``,
`-v`	`verbose`	Output shell input lines as they are read.
`-x`	`xtrace`	Output a trace of simple commands: `for , case , select and arithmetic for commands and their arguments or associated word lists after they are expanded and before they are executed. The value of $PS4 is expanded and the resultant value is output before the command and its expanded arguments.`
`-B`		Brace Expansion. On by default.
`-C`		Prevent output redirection using `> and <>` from overwriting existing files. (no clobber)
`-H`		Enable `!` style history substitution (see History Expansion). On by default for interactive shells.
`-P`		do not resolve symbolic links when performing commands such as `cd` which change the current directory. The physical directory is used instead. By default, Bash follows the logical chain of directories when performing commands which change the current directory. For example, if `/usr/sys` is a symbolic link to `/usr/local/sys` then: $ cd /usr/sys; echo $PWD /usr/sys $ cd ..; pwd /usr If set`-P` is on, then: $ cd /usr/sys; echo $PWD /usr/local/sys $ cd ..; pwd /usr/local
`-E`		trap on `ERR` is inherited by shell functions, command substitutions and commands executed in a subshell environment, normally not inherited in such cases.
`-T`		trap on DEBUG and RETURN are inherited by shell functions, command substitutions, and commands executed in a subshell environment, normally not inherited in such cases. If no arguments follow this option, then the positional parameters are unset. Otherwise, the positional parameters are set to the arguments, even if some of them begin with a `-`.
`-`		end of options, causes remaining arguments to be assigned to the positional parameters. `-x` and `-v` are turned off.

If there are no arguments, the positional parameters remain unchanged.

The options can also be used upon invocation of the shell. The current set of options may be found in $-

. The remaining N arguments are positional parameters and are assigned, in order, to $1, $2, … $N. The special parameter # is set to N. The return status is 0 unless an invalid option is supplied.

The options are off by default unless otherwise noted.
Using + turns the option off^sic.
The options can also be specified as arguments to an invocation of the shell.
The current set of options may be found in $-.
The return status is always true unless an invalid option is encountered.

unset [-fv] [`name` … ]

Each variable or function name is removed.
With -v or without options name is a variable.
With -f name refers to functions, and the definition is removed.
Readonly variables and functions may not be unset.

shift [`n`]

Shift the positional parameters of the fuction to the left by n that is:
reduce the reference of each parameter, starting at the given, number by 1 … and reduce the number of parametrws ($#) by n.

alias eco='/bin/echo -n'
function func() {                       func aa bb cc
eco #:$#: one:$1:;  eco two:$2:               #:3: one:aa:  two:bb:
shift; eco "  <<shifted"                  <<shifted 
eco #:$#: one:$1:;  eco two:$2:               #:2: one:bb:  two:cc:
}

n must ≥ 0 ≤ to the original number of parameters and the default is 1. n must ≥ 0 and ≤ to $#.
Parameters previously following the n<>sup>th$0, is not affected.
The return status is 0.

shopt^Ź [-pqsu] [-o] [`option` …]

(1437) Set variables controlling shell behavior.

Display the list if no options specified:

cdable_vars   off
cdspell       off
checkhash     off
checkwinsize  off
cmdhist       on
dotglob       off

execfail        off
expand_aliases  on^†
extdebug        off
extglob         off
extquote        on
failglob        off
force_fignore   on

  
gnu_errfmt    off
histappend    off
histreedit    off
histverify    off
hostcomplete  on
huponexit     off

interactive_comments on
lithist         off
login_shell     on
mailwarn        off
no_empty_cmd_completion off
nocaseglob      off
nocasematch     off
nullglob        off

progcomp         on
promptvars       on
restricted_shell off
shift_verbose    off
sourcepath       on
xpg_echo         off

`-p`	prints options in a form that may be reused as input. … shopt -u extglob shopt -s extquote …
`-s`	set an `option`. Without `option` lists the options that are set
`-u`	unset an `option`. Without `option` lists the options that are unset
`-q`	quitely continue, the return status indicates whether the `option` is set or unset. If multiple `option`s with `-q`, the return status is zero if all are enabled; non-zero otherwise.
`-o`	Restricts `option`s to be those for the `-o` option to the `set` builtin.

shopt options are disabled (off) by default.
Return Status:

when listing options: 0 if all option are enabled.

when setting or unsetting options: 0 unless an option is not a valid.

`cdable_vars`	if `cd` doesn't specifiy a directory, it is a variable whose value is a directory. (No `$` ) /home2/reer1 > export docs=/home2/reer1/www/docs /home2/reer1 > cd docs /home2/reer1/www/docs >
`cdspell`	`cd` with minor spelling errors are corrected . transposed characters, a missing character, and a character too many. If a corrected , the corrected path is displayed, and the command proceeds. Only for interactive shells.
`checkhash`	check if a command in the hash table exists before trying to execute it. If it no longer exists, a normal path search is performed.
`checkwinsize`	updates `LINES` and `COLUMNS` after each command incase terminal window was resized.
`dotglob`	include filenames beginning with a `.` in the results of filename expansion.
`execfail`	a non-interactive shell will not exit if it cannot execute the file specified as an argument to the `exec` builtin command. An interactive shell does not exit if `exec` fails.
`expand_aliases`	`on` by default for interactive shells, `off` by default in scripts
`extglob`	extended (pattern matching) is enabled.
`histappend`	the history list is appended to `HISTFILE` when the shell exits, rather than overwriting the file. See bashHistory
`histreedit`	re-edit a failed substitution is permitted with `Readline`
`histverify`	Resulting line is loaded into the Readline editing buffer, allowing further modification.
`cmdhist`	Save all lines of a multiple-line command in the same history entry. Example: > for j in 0 1 2 > do > echo $j > done 0 1 2 ␛k (recall last command if vi is command line editor) > for j in 0 1 2; do echo $j; done
`lithist`	with `cmdhist` multi-line commands are saved to the history with embedded newlines See bashHistory
`hostcomplete`	hostname completion when a word containing a `@` is being completed with `Readline`. enabled by default.
`huponexit`	send `SIGHUP` to all jobs when an interactive login shell exits (see Signals).
`interactive_comments`	Allow a word beginning with `#` to cause that word and all remaining characters on that line to be ignored in an interactive shell. enabled by default.
`mailwarn`	If set, and a file that Bash is checking for mail has been accessed since the last time it was checked, the message `"The mail in mailfile has been read"` is displayed.
`nullglob`	filename patterns which match no files are expanded to a null string, rather than themselves.
`promptvars`	prompt strings undergo variable and parameter expansion after being expanded, enabled by default.
`shift_verbose`	If set `shift` builtin displays an error message when the shift count exceeds the number of positional parameters.
`sourcepath`	If set, the `source` builtin uses the value of `PATH` to find the directory containing the file supplied as an argument. enabled by default.

source

source filename A synonym for . ( dot )

times

Display the user and system times used by the shell and its children.

0m0.060s 0m0.260s
0m1.250s 0m2.240s

The return status is 0.

time [-p]

/usr/bin/time is probably what you want!

If a command begins with time the elapsed, user and system time consumed by its execution are reported when the pipeline terminates.

   0.0 wall time;  0.012 user; 0.009 sys; 59.06%

The -p option changes the output format to that specified by POSIX.

real 0.02
user 0.02
sys 0.00

The $TIMEFORMAT may be set to a format string. % introduces an escape sequence that is expanded to a time value or other information.

`%%`	"`%`"
`%[d][l]R`	elapsed time in seconds.
`%[d][l]U`	CPU seconds spent in user mode.
`%[d][l]S`	CPU seconds spent in system mode.
`%P`	CPU percentage, computed as (%U + %S) / %R.

d number of digits after a decimal point, 0-3.
longer format, including minutes, MMmSS.FFs.
Default \nreal\t%3lR\nuser \t%3lU\nsys\t%3lS

In posix mode, time may be followed by a newline. displays the total user and system time consumed by the shell and its children.
In posix mode, time is not recognized if the next token begins with a -.

trap [-lp] [`commands`] [`signal|sig_num` …]

commands are executed when the shell receives signal, then execution continues unless commands include exit.
If commands includes a function call, the function must be defined before the trap occurs.

Issuing a kill -SIG pid does NOT produce the same result as if the event occurs in the process.
in particular quit(usually ^\) vs kill -quit pid from another process.

trap-p displays commands associated with each signal.

trap displays commands associated with each signal number in a form that may be reused as shell input.

trap signal signal is ignored by the shell and commands it invokes.

trap - sig[, sig … signals reset to the values when the shell was started.

trap-l

lists signal names and their corresponding numbers.

signal		description	Default action
`EXIT`	0	shell exited
`DEBUG`		occurs after EVERY simple command. (noisy) example: `trap 'date +%T' DEBUG` See declare -t `name`
`ERR`		a simple command returns non-zero. example: `trap 'echo " -- RC:$?"' ERR`
`RETURN`		function or script executed with the `.`^† or `source` builtins finishes. See declare -t `name`
`HUP`	1	`telnet\|ssh` dissconnect/exit. Another process issued `kill -hup pid`. Terminal line hungup (Disconnected). If `bash huponexit` is set, bash sends `HUP` to all jobs when an interactive login shell exits.	terminate process Sometimes used to cause process to read it's configuration file.
`INT`	2	Interrupt. Usually ^C from controlling terminal. See stty -a	terminate process
`TERM`	15	Termination signal Issued by shutdown a few moments before issuing `kill` This is to permit processes to exit cleanly.	terminate process
`QUIT`	3	Quit. Usually `^\` from the controlling terminal See stty -a. Another process issued `kill -quit pid`. bash reports `line n: pid Quit` . from another terminal: kill -quit 5288 produces:Quit: 3 Typing `^c` at the terminal that issued `trap ..echo "I Quit!"`	`^\Quit: 3` (from the shell zsh) `^C quit` (from the script TRAP command). Terminates `sleep` and continues script. `I Quit!`
`KILL`	9	terminate process CANNOT BE TRAPPED!	outputs `Killed: 9` with `$?` = 137
`STOP^{‡ CHLD}`	17	Cannot be caught or ignored)	Stop process
`CONT^{‡ STOP}`	19	Continue after `stop`	Discard signal
`ABRT`	6	Abort (formerly IOT)	core dump
`ILL`	4	ILLegal instruction	core dump
`TRAP`	5	trace TRAP	core dump
`EMT^{‡ Bus}`	7	EMulaTe instruction executed	core dump
`FPE`	8	Floating-Point Exception	core dump
`BUS`	10	Bus error	core dump
`SEGV`	11	Segmentation Violation	core dump
`SYS^{‡ USR2}`	12	non-existent system call invoked	core dump
kill -usr2 5288 User defined signal 2: 31
from another terminal session: kill -sys 5231 /Users/xan/.bin/taill: line 28: 5231 Bad system call: 12 tail -n$x $1 $lastFile
`PIPE`	13	write on a PIPE with no reader	terminate process
`ALRM`	14	real-time timer expired (alarm)	terminate process
`URG^{‡ STKFLT}`	16	Urgent condition present on socket	discard signal
`TSTP^{‡ CONT}`	18	Terminal generated stop (i.e. from keyboard)	stop process
`CHLD^{‡ TSP}`	20	Child status has changed(example: terminated)	discard signal
`TTIN`	21	TTY background INput attempted from control terminal
`TTOU`	22	TTY background OUtput attempted to control terminal
`IO^{See 29} URG`	23	I/O is possible on a descriptor (see fCntl )	discard signal
`XCPU`	24	Exceeded CPU time limit (see setRLimit) ulimit	terminate process
`XFSZ`	25	Exceeded File Size limit (see setRLimit) ulimit	terminate process
`VTALRM`	26	Virtual Time Alarm (see setITimer)	terminate process
`PROF`	27	Profiling timer alarm (see setItimer)	terminate process
`WINCH`	28	Window size CHange	discard signal
`INFO ^{‡ IO on linux}`	29	status request from keyboard usually ^t see stty -a	Discard signal. Some programs ( for example `dd`) report progress. reports: `I/O possible`
`USR1^{‡ PWR}`	30	User defined signal 1	terminate process
`USR2^{‡ SYS}`	31	User defined signal 2	terminate process
POSIX.1-2024 sigwait() for thread-safe signal handling, when SA_SIGINFO is set requires explicit casting to ucontext_t * SIGWINCH Window changes size. raise() is async-signal-safe even from within a signal handler.

^‡Different linux signals:

BUS   7      USR1 10      USR2 12   STKFLT 16 
CHLD 17      CONT 18      STOP 19   TSTP 20     URG 23   IO 29    PWR 30   SYS 31   
RTMIN 34     RTMIN+1 35   … RTMIN+15 49  
RTMAX-14 50  RTMAX-13 51  …RTMAX 64

Signals ignored upon entry to a shell cannot be trapped or reset.
A KILL issued to a process in a wait will cause the wait to expire immediately.
Signals issued by kill -signal PID remain pending if the script is processing a wait, until the wait expires!
Trapped signals are reset to their original values in a child process when it is created.
Return status: 1 if sigspec is not a valid signal.

Example: remove tmp files and exit with a return code of 2 when the terminal user presses ^c
trap "rm -f /tmp/${TMP}*; exit 2" SIGint

To make a script "safe" by limiting the execution time and filespace it can use and
write a message to a log if something "bad" happens:

ulimit -Sf 2000 -St 20   # set soft limits for files (KB) and cputime(seconds) 
export LOG=" ~/log/trap.log"
echo LOG:$LOG
date +"%D %T"
trap "echo ' -- trap `date +"%D %T"` OOPS. I was stuck in a loop ' >> $LOG \
                                        CLeanThingsUp.sh ; exit 24"           XCPU XFSZ
trap "echo ' -- trap `date +"%D %T"` OOPS. I stumbled ' >> $LOG; tail $LOG; exit 4" ILL FPE SEGV URG
trap "echo ' -- trap `date +"%D %T"` Sombody poked me ' >> $LOG; tail $LOG;exit 2"  INT QUIT USR1 USR2
trap "echo ' -- trap `date +"%D %T"` Something happened that was not my fault, executing $0 ' >> $LOG; exit 5" TRAP ABRT BUS VTALRM PROF ALRM
trap "echo ' -- trap `date +"%D %T"` Somebody wanted me to terminate ' >> $LOG; exit 15" TERM

# Kill cannot be caught

trap -p # show set traps

trap -- 'echo good bye ' EXIT
> logout
good bye 
Connection to real-world-systems.com closed.

Signals Handled by bash

See trap for prempting signals for a script.

	default keystrokes	see `stty> stty -a … cchars: discard=^O; dsusp=^Y; eof=^D; eol=; eol2=; erase=^?; intr=^C; kill=^U^†; lnext=^V; min=1; quit=^\; reprint=^R; start=^Q; status=^T; stop=^S; susp=^Z; time=0; werase=^W; intr=^C; quit=^\; killcharacters typedAhead=^U; eof=^D; eol=<undef> eol2=; swtch=; start=^Q; stop=^S; susp=^Z; rprnt=^R;`
`SIGQUIT`	`^\`	ignored.
`SIGTERM`	^c	ignored when Bash is interactive, in the absence of any traps, `kill TERM p` does not terminate an interactive shell
`SIGINT`	^c	caught and handled (so that `wait` is interruptible) and bash breaks out of any loops. Ignored by asynchronous commands
`SIGTTIN` `SIGTTOU` `SIGTSTP`		ignored if Job Control is in effect. ignored for commands run as a result of command substitution
`SIGHUP`		Causes the shell to exit by default. Before exiting, all job are sent `SIGHUP` . Stopped jobs are first sent `SIGCONT` to ensure that they receive the `SIGHUP`. To prevent the shell from sending the `SIGHUP` signal to a particular job, it should be removed from the jobs table with `disown` (see Job Control) or marked to not receive `SIGHUP` using `disown -h`. If `huponexit` is set bash sends `SIGHUP` to all jobs when an interactive login shell exits.

If BASH receives a signal, for which a trap has been set, while waiting for a command to complete, will not be executed until the command completes.
If waiting for an asynchronus command a 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.

Additional signals , passed to process

type

[--afPt^†pa] [name …]

For each name, display how it would be interpreted as a command.

-a all of the places that contain an executable named keyword,

-p file that would be executed, or nothing if -t would not return file.
file including aliases and functions, if and only if the

-t display the type i.e. alias, function, builtin, file or keyword.

-p option is not used.
The return status is 0 if any of the names are found, non-zero if none are found.

Output is shown on the same line for clarity. ed

> type wc        wc is /usr/bin/wc 
> type SHELLOPTS -bash: type: SHELLOPTS: not found 
> type sopt      -bash: type: sopt: not found 
> type shopt     shopt is a shell builtin
> type set       set is a shell builtin
> type {         { is a shell keyword 
> type emacs     emacs is /usr/bin/emacs
> type errexit   -bash: type: errexit: not found
> type cd        cd is a shell builtin 
> type CD        CD is /usr/bin/CD  surprise ?
> type ls        ls is aliased to `ls -F' 
> type -t ls     alias 
> type -a ls     ls is aliased to `ls -F'
                 ls is /bin/ls 
> type echo      echo is a shell builtin
> type ECHO      ECHO is /bin/ECHO uppercase!  surprise ? 
> type -a ECHO   ECHO is /Volumes/DATA/dgerman/.bin/ECHO
                 ECHO is /bin/ECHO

> type -a echo  echo is a shell builtin
                echo is /Volumes/DATA/dgerman/.bin/echo
                echo is /bin/echo

ulimit [-S|H] [-a]|[-cdflmnpstuv] [`value`]

Provides control over resources, useful in preventing "run-away" processes.

`-S`	Soft limits
`-H`	Hard limits

When setting limits both are set by detault (not the best idea).

`-a`	display all limits.
`-t`	seconds of cpu time (not wall tme)
`-f`	files size used. (1024 byte blocks)
`-u`	number of user processes
`-p`	pipe buffer size. ( 512 byte blocks)
`-n`	number of open file descriptors.
`-c`	core (dumps) file space used(seperate from other files).
`-d`	data segment size.
`-s`	stack size.
`-l`	size that may be locked into memory.
`-m`	resident set memory size.
`-v`	amount of virtual memory

A Soft limit can be changed up to the maximum set by the Hard limit.
Once a process decreases a Hard limit it cannot be increased.

ulimit affects the current shell environment, it does not affect the limits of the caller .

Examples:
ulimit -t 3
When the total CPU time reaches 3 seconds
Cputime limit exceeded: 24

ulimit -f 2 > tar -cf t * File size limit exceeded (core dumped)

See trap XCPU , XFSZ

The return status is 0 unless an invalid option is supplied or a non-numeric argument (other than unlimited) is supplied ( status = 2) as a limit or an error occurs while setting a new limit.
Attempting to change a limit above the Hard limit produces the error:

     -bash: ulimit: file size: cannot modify limit: Operation not permitted

And returns a status of 1.

umask [-p] [-S] [`mode`]

`-S`	symbolic not numeric i.e. rwx not not 027
`-p`	p in format usable as input (Mac OS X darwin

wikipedia version is good

test `expr`

also written as [expr

Evaluate a conditional expression.
Operators and operands must be separate arguments (i.e. surrounded by whitespace).
Parenthesis ( ) groups arguments to override the normal precedence (or improve clarity).

#^†	format	result	exception
1	`test $var`	TRUE if `$var` is TRUE	TRUE if `$var` is not null i.e. `$VAR` has been assigned a value (perhaps within a function).
	`test ! $var`	TRUE if `$var` is FALSE. (negation).	TRUE if `$var` is null.
	`test -f loginhush`	TRUE if the evaluation is TRUE. In this example `-f` "is a regular file".	FALSE if the operator is not a unary operator. In this example -exists should be `-e`
	`test -exists mysrc`
3	`test $SUM -gt 0`
	`test ( $VAR )`	If the 1^st argument is `!`, the value is the negation of the 2 argument test 2^nd and 3^rd arguments.
	`( xxxx )`	the result is the test of `xxxx`
		Otherwise, the expression is false. `-a` (and) and `-o` (or) are considered logical binary operators in this case.
4	`test ! $SUM -gt 0` required space after !	leading `!`, i.e. negative of remaining 3 args as above

Example:
If the touch is successful the return code ( ${?} ) will be equal to 0 and the exit statment ( part of the OR list ) will NOT be executed. The script will continue.

touch CMakeLists.txt
test ${?} -eq 0 || ( echo "-- failed, exiting"; exit $rc

 test ${?} -ne 0 && exit ${?}

See command lists for even simpler example involving the return code>

Conditional Expressions

See simple list of commands like:
try_to_do_stuff && do_more_stuff_since_it_is_going_well
try_to_do_stuff || clean_up_mess_from_failured_stuff

used by

[[ conditional expressions
test and [ builtin and
if reserved word.

The syntax of the if command.

-bash: [: -eq: unary operator expected Is reported when attempting to compare an unset $variable.

Expressions may be unary or binary^†.

String (for example an environment variable) not necessarily quoted		Numeric `ARG1` and `ARG2` are signed integers	logical
`$str1 <^† str2` (example where `$str1` is an argument)	would `$str1` sort before `str2`	`$# -lt n` `$# -le n`	`!` Negate
`$str1 == str2` `$str1 = str2`	zsh doesn't support `==` within the `[ ]` test command, Use `[[ ]]`.	`-eq`	`-a` AND
`$str1 != str2`	not equal.	`-ne` $rc -ne 0 exit $rc	`-o` OR
`$str1 >^† str2`	`if [ $rc >1 ]; then echo "oops";fi AND file 1 is klobbered! str1 sorts after str2`	`-gt`
`-z $str`	length of `$str` is zero.
`-n $str`	length of `$str` is not zero.

String compares are not the same as numeric.
Results in red may not be as expceted:


> if [ 01 ==  1 ]^z; then echo EQUAL; else echo NO ; fi  

NO 
(== does a string compare)
> if [ "01" -eq  1 ]; then echo EQUAL; else echo NO ; fi 

EQUAL 
(-eq does a numeric compare)

> if [ 01 -eq 1 ]; then echo EQUAL; else echo NO ; fi  

EQUAL  



> if [ "1" == 1 ]; then echo EQUAL; else echo NO ; fi 

EQUAL 

> if [ "1" -eq  1 ]; then echo EQUAL; else echo NO ; fi 

EQUAL

> if [ 1 ]; then echo TRUE ;fi TRUE > if [ 0 ]; then echo TRUE ;fi TRUE

Don't use to test for null argument see ParamExpansions

The status of a file^† can be checked with:

`-a` exists `-e` exists if [ -e flagfile ] ; then echo "flagfile present, I must be already working"; exit else echo flagfile was not there. touch flagfile echo work, work, work . . . fi
`-d` its a directory	`-s` size greater than zero	`-N` is New, i.e. modified since it was last read.
`-r` readable	`-w` writable	`if [ ! -x f ]; then` NOT executable (perhaps `which name` is better since it searches `$PATH`
`-u` set-user-id is set `-g` set-group-id is set `-k` "sticky" bit is set	`-O` owned by the effective user id `-G` owned by the effective group id
`-f` regular file. `-L` symbolic link `-b` block special		`-c` character special file `-S` socket `-p` named pipe (FIFO).	`-t fd` file descriptor `fd` is open and refers to a terminal.

file1 -nt file2 file1 is Newer Than (according to modification date) file2.
file1 -ot file2 file1 is Older Than file2.

file1 -ef file2 file1 and file2 have the same device and inode numbers. (they are hard linked)

If any file argument to one of the primaries is of the form /dev/fd/N, then file descriptor N is checked.

-z $str length of $str is 0.
-n $str length of $str is not 0.

-o optname shell option optname is enabled.
(The list of options appears in the description of -o to the set builtin.

these

>>>>??? -h file True if file is a symbolic link.
-O file True if the file is effectively owned by you.
-G file True if the file is effectively owned by your group.

if FILE is a symbolic link, file operators except -h and -L refer to the target of a symbolic link, not on the symlink itself,

String operators:
-o option True if the shell option is enabled.
-v $VAR True if the shell variable $VAR is set.
-R $VAR True if the shell variable $VAR is set and is a name reference.
arg1 OP arg2 Arithmetic tests. OP is one of -eq, -ne, -lt, -le, -gt, or -ge.

Arithmetic binary operators return true if arg1 is

equal, not-equal,
    less-than, less-than-or-equal, greater-than, or greater-than-or-equal

to
arg2.

Exit Status:
Returns success if EXPR evaluates to true; fails if EXPR evaluates to false or an invalid argument is given.

Test if an environmental variable has a value by concatenating it with x; check against null.
if [ "$VAR"x = ""x ] ; then …

See expansion "${1:-}" to test function argument.

top

Shell Arithmetic

Arithmetic expressions are be evaluated by let

 > let i=$j+4 ; echo $i # no spaces!
 12

or as a shell expansion.

 > echo $((13/6))
 2

Evaluation is done in long integers with no check for overflow.
Division by 0 is trapped and flagged as an error.

$ r=0
% let c=1/$r
-bash: let: c=1/0: division by 0 (error token is "0")

Operators in order of decreasing precedence,
grouped with equal-precedence operators.

`+ -`	unary plus and minus
`!` `~`	logical and bitwise negation
`**`	exponentiation

`* / %`	multiplication division remainder
`+ -`	addition subtraction
`<< >>`	left & right bitwise shifts

`<= >= < >`	comparison
`== !=`	equality & inequality

`&`	bitwise AND Consider an observed value of x'65' and a mask of x'0F'; meaning preserve/evaluate the right nibble	x'65' & x'0F' x'05'	0110 0101 & 0000 1111 0000 0101
`^`	bitwise eXclusive OR Consider an existing value of x'0E' and a "flip pattern" of x'FC', i.e. where 1s exist in the pattern, existing bits are flipped, where 0s exist in the pattern the existing bits are preserved.	x'0E' ^ x'FC' x'F2'	0000 1110 ^ 1111 1100 1111 0010
`\|`	bitwise OR Consider an existing value of x'05'; and a "enabling" 1^st bit, x'80'	x'05' ^\| x'80' x'85'	0000 0101 \| 1000 0000 1000 0101
`&&`^†	logical AND	`if [ "$myanswer && $youranswer"^† ]`
`\|\|`^†	logical OR
`TestExpr ? trueExprResult : falseExpreResult`		conditional evaluation
`= *= /= %= += -= <<= >>= &= ^= \|=`		assignments > let x=8; let x+=9; echo $x 17

Variables are allowed as operands.
Parameter expansion is performed before the expression is evaluated.
The value of a parameter is coerced to a long integer within an expression.
A variable need not have its integer attribute turned on to be used in an expression.

Constants with a leading 0x or 0X are hexadecimal (example: 0x0A, 0xFC, 0X0a),
leading 0 are octal (example: 0777, 0755, 0700).
Otherwise, numbers take the form [base]n, where base is a decimal number between 2 and 64 representing the arithmetic base, and n is a number in that base. Default base is 10.
The digits greater than 9 are represented by lowercase letters , UPPERCASE LETTERS, _, and @, in that order.
If base is less than to 37, either lowercase and uppercase may be used.

Operators are evaluated in order of precedence.
Sub-expressions in parentheses are evaluated first.

Arrays

Array varriables are one-dimensional, zero-based ^{and

are created using
declare -a name

The index is an arithmetic expression that evaluates to 0 or a positive integer.

Attributes may be specified for an array variable using declare and
-r (readonly) applies to all members of an array.}

Arrays are assigned using compound assignments of the form name=(value1 … valueN)
where each value is of the form [[index]=]string. If the index is supplied, that index is assigned to; otherwise the index is the last index assigned plus one.
This syntax is also accepted by declare.
Individual array elements may be assigned to using the name[subscript=value.

Use declare -a to display all arrays and attributes.

Elements of an array are referenced using ${name[subscript]}.
An index of @ or * expands to all members of the array.
These indexes differ only when the word appears within quotes (").
If the word is quoted, ${name[*]} expands to a single word with the value of each array member separated by the first character of the IFS^† variable, and ${name[@]} expands each element of name to a separate word.
When there are no array members, ${name[@]} expands to nothing. This is analogous to the expansion of the special parameters @ and *.
${#name[index]} expands to the length of ${name[index]}.
If index is @ or *, the expansion is the number of elements in the array.
Referencing an array variable without a subscript references element zero.

unset name[index] destroys that array element .
unset name removes the entire array as does a subscript of * or @.

declare, local, and readonly accept -a to specify an array.
read accepts -a to assign a list of words read from the standard input to an array, and can read values from the standard input into individual array elements.
set and declare display array values in a way that allows them to be reused as input.

top

The Directory Stack

The directory stack is the array $DIRSTACK.

set|grep DIRS
echo $DIRS
DIRSTACK=([0]="~" [1]="/Volumes/homes/sams/Documents/computerstuff/firmware" [2]="/Volumes/DATA/homes/sams/bin")

dirs

displays the directory stack^Z, or current directory if stack is empty!

dirs [+N | -N] [-clvp]

`+N`	Displays the `N`^th directory (counting from the left of the list (origin zero)
`-N`	Displays the `N`^th from the right
Not `zsh`:
`-p`	display the directory stack, one entry per line
`-v`	prefix each entry with its index, one entry per line dirs -v 0 ~ 1 ~/mail/real-systems.com/dgerman 2 ~/mail/real-systems.com 3 ~/mail 4 ~ 5 ~/www/docs
`-l`	long format; the default format uses a tilde to denote the home directory. /home/sam /home/sam/mail/real.com/dgerman /home/sam/mail/real.com /home/sam/mail /home/sam /home/sam/www/docs
`-c`	Clears the directory stack

pushd [dir | +N | -N] [-n]

adds entries to $DIRSTACK as it changes the current directory,
Save the current directory on the top of the directory stack and then cd to dir, then displays $DIRSTACK.
With no arguments, pushd changes back to the previous directory by exchanging the top two directories and changes the current directory to the new top directory.

`dir`	Makes the current working directory be the top of the stack, and then `cd`s to `dir`.
`+N`	Brings the `N`th directory from the left of the list to the top of the list by rotating the stack.
`-N`	Brings the `N`th directory from the right to the top of the list by rotating the stack.
`-n`	No `cd` is performed and no check that `dir` is valid!

popd [+N | -N] [-n]

removes entries from the stack and changes the current directory to the directory removed.

`+N`	Removes the `N`th entry, from the left
`-N`	Removes the `N`th entry, from the right
`-n`	No `cd` is performed

If the top entry is not valid, the current directory is unchanged and the stack is unchanged.
Use popd -n to remove an invalid entry.

 /home/rear1/www/docs > pushd ../birding
~/www/birding ~/www/docs
/home/reer1/www/birding > pushd log
~/www/birding/log ~/www/birding ~/www/docs
/home/reer1/www/birding/log > pushd data
~/www/birding/log/data ~/www/birding/log ~/www/birding ~/www/docs
/home/reer1/www/birding/log/data > dirs -v -p
 0  ~/www/birding/log/data
 1  ~/www/birding/log
 2  ~/www/birding
 3  ~/www/docs
/home/reer1/www/birding/log/data > popd -2
~/www/birding/log/data ~/www/birding ~/www/docs
/home/reer1/www/birding/log/data > dirs -v -p
 0  ~/www/birding/log/data
 1  ~/www/birding
 2  ~/www/docs
/home/reer1/www/birding/log/data > popd -2
~/www/birding ~/www/docs
/home/reer1/www/birding > dirs -v  
 0  ~/www/birding
 1  ~/www/docs

See cd

Controlling the Prompt

Bash executes PROMPT_COMMAND before displaying $PS1 or $PS2 (used when for continuation lines) $ENVIRONMENT VARIABLES

`$PROMPT_DIRTRIM`	number of trailing directory components for `\w and \W`
`$PROMPT_COMMAND`	executed prior to issuing primary prompt.

Special characters used in the prompt :

`\a` Alert aka bell `\n` newline. `\r` return. `\\` backslash.
`\e`	escape ( x'1B') used to introduce terminal commandsi Example `export PS1='\e[7m>\e[0m '` This sets characters dim, displays > and resets caracter attributes.
`\d`	date, in "Weekday Month Date" format (e.g., "Tue May 26").
`\t`	HH:MM:SS `\T` HH:MM:SS 12-hour format. `\@` am/pm
`\$`	If the effective uid is 0 (i.e.root), `#`, otherwise `$`.
`\u`	current username
`\w`	Current Working Directory.
`\h` `\H`	hostname, up to the first .
`\s`	name of the shell, the basename of `$0` (the portion following the final slash).
`\v`	version of Bash (e.g., 2.00) `\V` release of Bash, version + patchlevel (e.g., 2.00.0)
`\W`	basename of `$PWD`.
`\!`	history number of this command.
`\#`	command number of this command.
`\nnn`	character whose ASCII code is octal `nnn`.
`\[`	Begin sequence of non-printing characters like terminal control sequences for example colors
`\]`	End sequence

Example including setting the prompt with color coding:
PS1='\[\e[32m\]\u@\h\[\e[0m\]:\[\e[34m\]\w \$\[\e[0m\]'
Where 32m sets green; \u displays the username, , \h the host, and 0m resets the color to black.
Myuname@THeHostIamOn:/home/myhome
See ANSI Characteres

top, Controlling the prompt

Variables

gnu

~

       $_

(underscore)

At shell startup, the pathname used to invoke the shell or shell script being executed as passed in the environment or argument list.

After startup, last argument to the previous simple command executed in the foreground, after expansion.
Full pathname used to invoke each command executed and placed in the environment exported to that command.

When checking mail, holds the name of the mail file.

HOME current user's home directory; default for cd and used by Tilde Expansion.

IFS Input Field Seperaters, list of characters that separate fields; used when spliting words as part of expansion.

MAIL If set to a filename and $MAILPATH is not set, Bash informs the user of the arrival of mail in the file.

MAILPATH Colon separated list of entries periodically checked for new mail, in the form: filename[?message]
In message, $_ expands to the filename.

MAILCHECK Seconds to check for mail in the files specified in $MAILPATH or $MAIL.

OPTARG Value of the last option argument processed by getopts

OPTIND Index " " " " "

CDPATH Colon-separated list of directories used as a search path for cd.

PATH

Colon separated list of directories searched (left to right) to locate a command.
Example:

echo $PATH

                     /usr/bin:/bin:/sbin:/usr/local/bin

If home directory is not in $PATH use ~/scriptname or
if the current directory are in $HOME use ./scriptname.

To have the home directory searched first use export PATH=~:$PATH

$PS1 Primary prompt string, default \s-\v\$ (i.e. shellname-version$).
Often set in .profile to export PS1='$PWD > ' resulting in the display of the Working Directory as the prompt.

PS2 Secondary prompt string used for continuation lines default > , perhaps export PS2=' + ' is a better choice.

$PS3 select prompt . Default #?

$PS4 Prompt before command is echoed with -x xtrace set.
The first character of PS4 is replicated multiple times, as necessary, to indicate multiple levels of indirection.
The default is + .

$PROMPT_COMMAND a command executed before the outputting primary prompt ($PS1).

BASH full pathname used to execute the current instance of Bash.

BASH_ENV Name of a startup file to read before executing the script.(subject to expansion)

BASHOPTS

A colon-separated list of enabled shell options.
Each word is a valid argument for shopt -s opt.
When Bash starts, each shell option in the list will be enabled before reading any startup files. ReadOnly.

echo $BASHOPTS
cmdhist:expand_aliases:extquote:force_fignore:hostcomplete:interactive_comments:login_shell:progcomp:promptvars:sourcepath

BASHID Process ID of the current Bash process. This differs from $$ under certain circumstances, such as subshells that do not require Bash to be re-initialized.

BASH_ALIASES List of aliases

BASH_ARGC

BASH_ARGE

BASH_ARGV

BASH_ARG0

BASH_COMMAND

BASH_COMPAT

BASH_ENV

BASH_EXECUTION_STRING

BASH_LINENO

BASH_LOADABLES_PATH

BASH_REMATCH

BASH_SOURCE

BASH_SUBSHELL

BASH_XTRACEFD

COLUMNS

EPOCHREALTIME

EPOCHSECONDS

DIRSTACK contents of the directory stack in an Array in the order they are displayed by dirs .
pushd and popd add and remove directories.
Assignment to this variable does not change the current directory.
If DIRSTACK is unset, it loses its special properties.

FCEDIT editor used by default by -e to edit history fc .

FIGNORE filename suffixs to ignore when performing filename completion, colon-separated list
A sample value is .o:~ to ignore object file and edit backups.

GLOBIGNORE A colon-separated list of patterns defining the set of filenames to be ignored by filename expansion. If a filename matched by a filename expansion pattern also matches one of the patterns in GLOBIGNORE, it is removed from the list of matches.

GROUPS An array variable containing the list of groups of which the current user is a member. readonly.

histchars^†

See
Using
history

!^# are normally used . Up to three characters which control History Expansion , quick substitution, and tokenization

The first character is the history-expansion-char, which signifies the start of a history expansion, normally !.
The second character signifies quick substitution when seen as the first character on a line, normally ^.
The optional third character indicates that the remainder of the line is a comment when found as the first character of a word and causes history substitution to be skipped for the remaining words on the line, usually #. It does not necessarily cause the shell to treat the rest of the line as a comment.

See shopt options

HISTCMD Set to the index in the history list of the current command. If HISTCMD is unset, it loses its special properties, even if it is subsequently reset.

HISTCONTROL ignorespace don't enter lines which begin with a space or tab into the history list.
ignoredups don't enter lines which match the last entered line (even cd .. (maybe not a good idea ed).
ignoreboth combines the two options.
Unset, or set to any other value than those above, means to save all lines on the history list.
The second and subsequent lines of a multi-line compound command are always added to history.

HISTIGNORE A colon-separated list of patterns used to determine which command lines are saved on the history list.
Each pattern is anchored at the beginning of the line and must fully specify the line (no implicit * is appended).
Each pattern is tested against the line after the checks specified by HISTCONTROL are applied.
& matches the previous history line. To include & in the pattern escape using a backslash
Continuation lines of a multi-line compound command are not tested, and are always added .
HISTIGNORE subsumes the function of HISTCONTROL.
A pattern of & is identical to ignoredups, and
a pattern of [ ]* is identical to ignorespace. Combining these two patterns, separating them with a colon, provides the functionality of ignoreboth.

HISTFILE file to which the command history is saved. default ~/.bash_history.

HISTSIZE maximum number of commands to remember on the history list.

HISTFILESIZE maximum number of lines contained in the history file.

HOSTFILE file in the same format as /etc/hosts that should be read when the shell needs to complete a hostname. You can change the file interactively; the next time you attempt to complete a hostname, Bash will add the contents of the new file to the already existing database.

HOSTNAME The name of the current host.

HOSTTYPE A string describing the machine Bash is running on.

IGNOREEOF Controls the action of the shell on receipt of an EOF character as the sole input. If set, the value denotes the number of consecutive EOF characters that can be read as the first character on an input line before the shell will exit. If the variable exists but does not have a numeric value (or has no value) then the default is 10. If the variable does not exist, then EOF signifies the end of input to the shell. This is only in effect for interactive shells.

INPUTRC Readline startup file . Default: ~/.inputrc.

LINENO The line number in the script or shell function currently executing.

MACHTYPE the system type in the standard GNU cpu-company-system format. (ex: i686-redhat-linux-gnu)

OSTYPE A string describing the operating system. (example linux-gnueabihf)

OPTERR If 1, displays error messages generated by getopts

PIPESTATUS list of exit status values from the processes in the most-recently-executed foreground pipeline (example ([0]="0"), as an Array

PPID parent process ID . readonly.

PWD Current working Directory set by cd .

OLDPWD previous Working Directory set by cd, used by cd -

RANDOM Each time this parameter is referenced, a random integer between 0 and 32767 is generated.
Assigning a value to this variable seeds the random number generator.

REPLY The default variable for the read builtin.

SECONDS

since SECONDS was last assigned. ( Initialy assigned when bash starts).
Useful for timing a section of a script.

> cat timeit                                    > sh -x timeit
SECONDS=start  # assign to anything resets      + SECONDS=start
time find . -name ss                            + find . -name ss
                                                . -name ss
                                                ./vacation/2019/iceland/ss
                                                ++++++++++++++++++++++++++++++++++++++++
                                                1 /tmp/find

                                                16.6 wall  0.039 user  0.171 sys  1.26%   output from time command
echo $SECONDS                                   + echo 17
                                                17


                        without  sh -x:         > ./timeit 
                                                . -name ss
                                                ./vacation/2019/iceland/ss
                                                ++++++++++++++++++++++++++++++++++++++++
                                                1 /tmp/find
                                                16.8 wall  0.039 user  0.171 sys  1.26%  
                                                17

SHELLOPTS

A colon-separated list of enabled shell options. Each word in the list is a valid argument for the -o option to set.
The options appearing in SHELLOPTS are those reported as on by set -o.
If in the environment when Bash starts up, each shell option in the list will be enabled before reading any startup files. readonly.

set -o


allexport       off
braceexpand     on
emacs           off
errexit         off
errtrace        off
functrace       off
hashall         on
histexpand      on
history         on
ignoreeof       off
interactive-comments    on
keyword         off

monitor         on
noclobber       off
noexec          off
noglob          off
nolog           off
notify          off
nounset         off
onecmd          off
physical        off
pipefail        off
posix           off
privileged      off
verbose         off
vi              on
xtrace          off

echo $SHELLOPTS
   braceexpand:hashall:histexpand:interactive-comments:monitor:vi

SHLVL Incremented by one each time a new instance of Bash is started. Level of how deeply shells are nested.

TIMEFORMAT

format string specifying how the timing information for pipelines prefixed with time should be displayed.
% introduces an escape sequence that is expanded to a time value or other information.

`%%`	"`%`"
`%[d][l]R`	elapsed time in seconds.
`%[d][l]U`	CPU seconds spent in user mode.
`%[d][l]S`	CPU seconds spent in system mode.
`%P`	CPU percentage, computed as (%U + %S) / %R.

d number of digits after a decimal point, 0-3.
longer format, including minutes, MMmSS.FFs.
Default \nreal\t%3lR\nuser \t%3lU\nsys\t%3lS

  real    0m1.000s
  user    0m0.000s
  sys     0m0.000s

export TIMEFORMAT="%1R wall %U user %S sys %P%%"

  0.1 wall  0.103 user  0.020 sys  78.64%

A newline is added.

TMOUT seconds bash waits for input after issuing the primary prompt before exiting.

UID numeric real user id of the current user .readonly.

EUID numeric effective user id of the current user. readonly.

LANG locale category for any category not specifically selected with a variable starting with LC_.

LC_ALL overrides the value of LANG and any other LC_ specifys locale category. (default: null).

LC_COLLATE collation order used when sorting the results of filename expansion, and behavior of range expressions, equivalence classes, and collating sequences within filename expansion and pattern matching ( Filename Expansion).

LC_CTYPE interpretation of characters and the behavior of character classes within filename expansion and pattern matching (Filename Expansion).

LC_MESSAGES locale used to translate double-quoted strings preceded by a $ (Locale-Specific Translation).

BASH The full pathname used to execute the current instance of Bash, example: /bin/bash

BASH_VERSION The version number of the current instance of Bash. ex: BASH_VERSION='2.05b.0(1)-release'

BASH_VERSINFO

A readonly array variable whose members hold version information for this instance of Bash.

`BASH_VERSINFO[0]`	The major version number (the `release`).
`BASH_VERSINFO[1]`	The minor version number (the `version`).
`BASH_VERSINFO[2]`	The patch level.
`BASH_VERSINFO[3]`	The build version.
`BASH_VERSINFO[4]`	The release status (e.g., `beta1`).
`BASH_VERSINFO[5]`	The value of `MACHTYPE`.

example: BASH_VERSINFO=([0]="2" [1]="05b" [2]="0" [3]="1" [4]="release" [5]="powerpc-apple-darwin8.0")

top, Variables (previous section)

Invoking Bash

Usually bash is invoked at login as specified in /etc/passwd or
as the first line of a script using #!/bin/bash

bash [long-options][-ir][-abefhklmnptuvxdBCDHP][-o option][argument …

bash [long-options]       [-abefhkmnptuvxdBCDHP] [-o option] -c string [argument …]

bash [long-options] -s    [-abefhkmnptuvxdBCDHP] [-o option] [argument …]

set options
Multi-character options must appear before the single-character options

`--init-file` `filename` == `--rcfile` `filename`	Execute commands from `filename` (instead of `~/.bashrc`) in an interactive shell. Startup Files description of the special behavior of a login shell.
`--noprofile`	Don't load ANY startup files ( system-wide `/etc/profile`, `~/.bash_profile`, `~/.bash_login`, or `~/.profile`) when invoked as a login shell.
`--norc`	Don't read the `~/.bashrc` in an interactive shell. on by default invoked as `sh`.
`--rcfile filename`	Execute commands from `filename` (instead of `~/.bashrc`) in an interactive shell.
`--noediting`	Do not use readline
`--restricted -r`	Make the shell a restricted shell (The Restricted Shell).
`--login -l`	act as if directly invoked by login. equivalent to `exec -l bash` but can be issued from another shell, such as `csh`. `exec bash --login` will replace the current shell with a Bash login shell.
`--posix`	Bash POSIX Mode
`--dump-strings -D`	A list of all strings that are subject to language translation when the current `locale` is not `C` is displayed on the standard ouput as double-quoted strings preceded by `$`.
`--dump-po-strings`	output is in the GNU `gettext` PO (portable object) format. `POSIX` (Locale-Specific Translation). Implies `-n` ; no commands will be executed.
`--verbose`	shows startup scripts too
`--help`	reformatted GNU bash, version 3.2.57(1)-release-(x86_64-apple-darwin15) Usage: /bin/bash [GNU long option] [option] ... /bin/bash [GNU long option] [option] script-file ... GNU long options: --debug --debugger --dump-po-strings --dump-strings --help --init-file --login --noediting --noprofile --norc --posix --protected --rcfile --restricted --verbose --version --wordexp Shell options: -irsD or -c command or -O shopt_option (invocation only) -abefhkmnptuvxBCHP or -o option Type `/bin/bash -c "help set"' for more information about shell options. Type `/bin/bash -c help' for more information about shell builtin commands. Use the `bashbug' command to report bugs.
`--version`	GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin15) Copyright (C) 2007 Free Software Foundation, Inc.
`[±]O [shopt_option]`	`shopt_option` one of the shell options accepted by the shopt builtin If `shopt_option` is present, `-O` sets the value ; `+O` unsets it. If `shopt_option` is not supplied, the names and values of the shell options accepted by shopt are displayed on the standard output. If the invocation option is `+O,` the output is displayed in a format that may be reused as input.
Single-character options that may be supplied at invocation which are not available with the `set` builtin.
`‑c string`	execute commands from `string` after processing the options, then exit. Remaining arguments are assigned to the positional parameters, starting with `$0`.
`-i`	Force the shell to run interactively.
`-s`	Commands are read from STDIN if this option is present, or if no arguments remain after option processing. This option allows the positional parameters to be set when invoking an interactive shell.
`--`	signals the end of options and disables further option processing. Any arguments after the `--` are filenames and arguments.
`--debugger`

An interactive shell is one whose input and output are both connected to terminals (as determined by isatty(3)), or one started with -i .

If arguments remain after option processing, and neither -c nor -s has been specified,
the first argument is a file containing shell commands (Shell Scripts).
Invoked in this fashion, $0 is set to the name of the file, and the positional parameters are set to the remaining arguments.
Bash reads and executes commands from this file, then exits.
Exit status is the exit status of the last command executed in the script.
If no commands are executed, the exit status is 0.

top, Invoking(previous section)

Startup Files

(Tildes are expanded in file names as described in Tilde Expansion.)
Files which exist but cannot be read, are reported as an error.

As the login shell commands are executed from:

/etc/profile
~/.bash_profile (Frequently includes a statment to run .bashrc).
~/.bash_login
~/.profile

--noprofile inhibits this.

When the login shell exits, commands are executed from:
~/.bash_logout

As an interactive shell (other than the login shell) or run by rshd, commands are executed from:
~/.bashrc (if it exists and is readablea).

--norc inhibits this.
--rcfile file use file instead of ~/.bashrc. after (or before) any login-specific initializations.(?) Ed.

rshd does not generally invoke the shell with those options or allow them to be specified.

When started non-interactively to run a script $BASH_ENV is used as the file to execute.
As if if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi were executed.
$PATH is not used to search for the file.

Invoked as sh, bash mimics the startup behavior of historical versions of sh and conforms to the POSIX standard.

interactive login shell, executes commands from:

/etc/profile
~/.profile

--noprofile inhibits this .

An interactive shell Bash uses $ENV to execute.
A non-interactive shell does not read any startup files.

Bash enters POSIX mode after the startup files are read.

When Bash is started in POSIX mode, as with --posix, it follows the POSIX standard for startup files. In this mode, interactive shells use the $ENV and executes from that file.
No other startup files are read.

If Bash is started with the effective user (group) id not equal to the real user (group) id:

no startup files are read,
shell functions are not inherited from the environment,
$SHELLOPTS is ignored and
the effective user id is set to the real user id.

If -p is supplied the effective user id is not reset.

top

Is This Shell Interactive?

As defined Invoking Bash: An interactive shell is one whose input and output are both connected to terminals (as reported by isatty(3)), or one started with the -i option.
This is reflecgted in the $- special variable with the presents of an i.

Startup scripts should test the value of $- special parameter. With a line like:
echo $- |grep --quite i || return # if not interactive return
before any output is generated otherwise sftp will report:Received message too long #### and refuse to connect! top

table of contents.

Bash Builtin Commands

: [arguments]

.† cmdfile aka source cmdfile

alias [-p] name=value [name=value…

unalias [-a] [alias_name … ]

bind

builtin [shell-builtin [args]]

command [-pVv] command [arguments …]

cd [-LP] [directory]

continue [n]

declare [-p | -afFrtxi] [name[=value]]

echo [-n[e|E] [args …]

enable [-n] [-p] [-f filename] [-ads] [name …]

eval [arguments]

exec [-cl] [-a name] [command [arguments]]

exit [n]

hash [-r] [-p filename] [command]

help [pattern]

let expression [expression]

local name[=value]…

logout[n]

printf format [arguments]