Ignore all text that follows on the same line. # is used in shell scripts as the comment character and is not really a command.

Used as the first line of a script to invoke the named shell (with optional arguments). Some older, non-Linux systems do not support scripts starting with this line. For example:

#!/bin/bash

Null command. Returns an exit status of 0. Sometimes used as the first character in a file to denote a bash script. Shell variables can be placed after the : to expand them to their values.

Example

Check whether someone is logged in:

if who | grep $1 > /dev/null
then :     # do nothing
     # if pattern is found
else echo "User $1 is not logged in"
fi

Same as source.

Assign a shorthand name as a synonym for cmd. If ='cmd' is omitted, print the alias for name; if name also is omitted or if [-p] is specified, print all aliases. See also unalias.

Print or set the bindings that allow keys to invoke functions such as cursor movement and line editing. Typical syntax choices for keys are "\C-t" for Ctrl-T and "\M-t" or "\et" for Esc T (quoting is needed to escape the sequences from the shell). Function names can be seen though the -l option.

Options

-f filename

Consult filename for bindings, which should be in the same format as on the bind command line.

-l

Print all Readline functions, which are functions that can be bound to keys.

-m keymap

Specify a keymap for this and further bindings. Possible keymaps are emacs, emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move, vi-command, and vi-insert.

-p

Display all functions and the keys that invoke them, in the format by which keys can be set.

-q function

Display the key bindings that invoke function.

-r key

Remove the binding attached to key, so it no longer works.

-s

Display all macros and the keys that invoke them, in the format by which keys can be set.

-u function

Remove all the bindings attached to function, so no keys will invoke it.

-v

Display all Readline variables (settings that affect history and line editing) and their current settings, in the format by which variables can be set.

-x key:command

Bind key to a shell command (recent; not in all bash versions in common use).

-P

Display all bound keys and the functions they invoke.

-S

Display all macros and the keys that invoke them.

-V

Display all Readline variables (settings that affect history and line editing) and their current settings.

Example

Bind Ctrl-T to copy-forward-word, the function that copies the part of the word following the cursor so it can be repasted:

$ bind "\C-t":copy-forward-word

Exit from the innermost (most deeply nested) for, while, or until loop, or from the n innermost levels of the loop. Also exits from a select list.

Execute command, which must be a shell built-in. Useful for invoking built-ins within scripts of the same name.

With no arguments, change to home directory of user. Otherwise, change working directory to dir. If dir is a relative pathname but is not in the current directory, then the CDPATH variable is searched.

Execute command; do not perform function look-up (i.e., refuse to run any command that is neither in PATH nor a built-in). Set exit status to that returned by command, unless command cannot be found, in which case exit with a status of 127.

-p

Search default path, ignoring the PATH variable's value.

--

Treat everything that follows as an argument, not an option.

Skip remaining commands in a for, while, or until loop, resuming with the next iteration of the loop (or skipping n loops).

Print or set variables. Options prefaced by + instead of - are inverted in meaning.

-a

Treat the following names as array variables.

-f

Treat the following names as functions.

-i

Expect variable to be an integer, and evaluate its assigned value.

-p

Print names and settings of all shell variables and functions; take no other action.

-r

Do not allow variables to be reset later.

-x

Mark variables for subsequent export.

-F

Print names of all shell functions; take no other action.

Print directories currently remembered for pushd/popd operations.

Options

+entry

Print entryth entry (list starts at 0).

-entry

Print entryth entry from end of list.

-l

Long listing.

Let job run, but disassociate it from the shell. By default, do not even list the job as an active job; commands like jobs and fg will no longer recognize it. When -h is specified, the job is recognized but simply is kept from being killed when the shell dies.

Options

-a

Act on all jobs.

-h

Do not pass a SIGHUP signal received by the shell on to the job.

Execute command in place of the current process (instead of creating a new process). exec also is useful for opening, closing, or copying file descriptors.

Options

-a name

Tell command that it was invoked as name.

-c

Remove all environment variables from the process when the new command runs.

-l

Treat the new process as if the user were logging in.

Examples

$ trap 'exec 2>&-' 0     Close standard error when
     shell script exits (signal 0)
$ exec /bin/tcsh         Replace current shell with extended C shell
$ exec < infile          Reassign standard input to infile

Exit a shell script with status n (e.g., exit 1). n can be zero (success) or nonzero (failure). If n is not given, exit status will be that of the most recent command. exit can be issued at the command line to close a window (log out).

Example

if [ $# -eq 0 ]; then
   echo "Usage:  $0 [-c] [-d] file(s)"
   exit 1     # Error status
fi

Pass (export) the value of one or more shell variables, giving global meaning to the variables (which are local by default). For example, a variable defined in one shell script must be exported if its value will be used in other programs called by the script. If no variables are given, export lists the variables exported by the current shell. If name and value are specified, assign value to a variable name.

Options

--

Treat all subsequent strings as arguments, not options.

-f

Expect variables to be functions.

-n

Unexport variable.

-p

List variables exported by current shell.

Assign each word in list to x in turn and execute commands. If list is omitted, $@ (positional parameters) is assumed.

Examples

Paginate all files in the current directory; save each result:

for file in *
do
     pr $file > $file.tmp
done

Search chapters for a list of words (like fgrep -f):

for item in `cat program_list`
do
     echo "Checking chapters for"
     echo "references to program $item..."
     grep -c "$item.[co]" chap*
done

Process command-line arguments (or args, if specified) and check for legal options. getopts is used in shell script loops and is intended to ensure standard syntax for command-line options. string contains the option letters to be recognized by getopts when running the shell script. Valid options are processed in turn and stored in the shell variable name. If an option letter is followed by a colon, the option must be followed by one or more arguments.

Search for commands and remember the directory in which each command resides. Hashing causes the shell to remember the association between a "name" and the absolute pathname of an executable, so that future executions don't require a search of PATH. With no arguments, hash lists the current hashed commands. The display shows hits (the number of times the command is called by the shell) and command (the full pathname).

Begin a conditional statement. Possible formats are:

if test-cmds    if test-cmds      if test-cmds
then          then             then
   cmds1        cmds1             cmds1
fi            else             elif test-cmds
                cmds2          then
              fi                  cmds2
                              ...
                               else
                                  cmdsn
                               fi

Usually, the initial if and any elif lines execute one test or [] command (although any series of commands is permitted). When if succeeds (that is, the last of its test-cmds returns 0), cmds1 are performed; otherwise each succeeding elif or else line is tried.

Options

+n

Remove the nth directory in the stack, counting from 0.

-n

Remove nth entry from the bottom of the stack, counting from 0.

Examples

$ printf "Previous command: %i\n" "$(($HISTCMD-1))"
Previous command: 534
$ echo $PAGER
less -E
$ printf "%q\n" "\t$PAGER"
\\tless\ -E

The last command probably would be used to record a setting in a file where it could be read and assigned by another shell script.

Options

+n

Rotate the stack to place the nth (counting from 0) directory at the top.

-n

Rotate the stack to place the nth directory from the bottom of the stack at the top.

Options

-a var

Read each word into an element of var, which is treated as an array variable.

-d char

Stop reading the line at char instead of at the newline.

-e

Line editing and command history are enabled during input.

-n num

Read only num characters from the line.

-p string

Display the prompt string to the user before reading each line, if input is interactive.

-r

Raw mode; ignore \ as a line continuation character.

-s

Do not echo the characters entered by the user (useful for reading a password).

-t seconds

Time out and return without setting any variables if input is interactive and no input has been entered for seconds seconds.

Examples

$ read first last address
Sarah Caldwell 123 Main Street
$ echo "$last, $first\n$address"
Caldwell, Sarah
123 Main Street

The following commands, which read a password into the variable $user_pw and then display its value, use recently added options that are not in all versions of bash in current use.

$ read -sp "Enter password (will not appear on screen)" user_pw
Enter password (will not appear on screen)
$ echo $user_pw
You weren't supposed to know!

The following script reads input from the system's password file, which uses colons to delimit fields (making it a popular subject for examples of input parsing).

IFS=:
cat /etc/passwd |
while
read account pw user group gecos home shell
do
echo "Account name $account has user info: $gecos"
done

Options

-a

Treat the following names as array variables.

-f

Treat the following names as functions, and set them read-only so that they cannot be changed.

-p

Display all read-only variables (default).

Options

-

Turn off -v and -x, and turn off option processing.

--

Used as the last option; -- turns off option processing so that arguments beginning with - are not misinterpreted as options. (For example, you can set $1 to -1.) If no arguments are given after --, unset the positional parameters.

-a

From now on, automatically mark variables for export after defining or changing them.

-b

Report background job status at termination, instead of waiting for next shell prompt.

-e

Exit if a command yields a nonzero exit status.

-f

Do not expand filename metacharacters (e.g., * ? [ ]). Wildcard expansion is sometimes called globbing.

-h

Locate commands as they are defined, and remember them.

-k

Assignment of environment variables (var=value) will take effect regardless of where they appear on the command line. Normally, assignments must precede the command name.

-m

Monitor mode. Enable job control; background jobs executes in a separate process group. -m usually is set automatically.

-n

Read commands, but don't execute. Useful for checking errors, particularly for shell scripts.

-o [m]

List shell modes, or turn on mode m. Many modes can be set by other options. The modes can be turned off through the +o option. Modes are:

allexport

Same as -a.

braceexpand

Same as -B.

emacs

Enter Emacs editing mode (on by default).

errexit

Same as -e.

hashall

Same as -h.

histexpand

Same as -H.

history

Default. Preserve command history.

ignoreeof

Don't allow use of a single Ctrl-D (the end-of-file or EOF character) to log off; use the exit command to log off. This has the same effect as setting the shell variable IGNOREEOF=1.

interactive-comments

Treat all words beginning with #, and all subsequent words, as comments.

keyword

Same as -k.

monitor

Same as -m.

noclobber

Same as -C.

noexec

Same as -n.

noglob

Same as -f.

notify

Same as -b.

nounset

Same as -u.

onecmd

Same as -t.

physical

Same as -P.

posix

Match POSIX standard.

privileged

Same as -p.

verbose

Same as -v.

vi

Enable vi-style command-line editing.

xtrace

Same as -x.

+o [m]

Display modes or turn off mode m. See the -o option for a list of modes.

-p

Start up as a privileged user; don't process $HOME/.profile.

-t

Exit after one command is executed.

-u

Indicate an error when user tries to use a variable that is undefined.

-v

Show each shell command line when read.

-x

Show commands and arguments when executed, preceded by a + or the prompt defined by the PS4 shell variable. This provides step-by-step debugging of shell scripts. (Same as -o xtrace.)

-B

Default. Enable brace expansion.

-C

Don't allow output redirection (>) to overwrite an existing file.

-H

Default. Enable ! and !! commands.

-P

Print absolute pathnames in response to pwd. By default, bash includes symbolic links in its response to pwd.

Examples

set -- "$num" -20 -30  Set $1 to $num, $2 to -20, $3 to -30
set -vx                Read each command line; show it;
                                              execute it; show it again (with arguments)
set +x                 Stop command tracing
set -o noclobber       Prevent file overwriting
set +o noclobber       Allow file overwriting again

Option

-f

Force suspend, even if shell is a login shell.

File conditions

-a file

file exists.

-b file

file is a block special file.

-c file

file is a character special file.

-d file

file is a directory.

-e file

file exists.

-f file

file is a regular file.

-g file

file has the set-group-ID bit set.

-h file

file is a symbolic link.

-k file

file has its sticky bit (no longer used) set.

-p file

file is a named pipe (FIFO).

-r file

file is readable.

-s file

file has a size greater than 0.

-t [n]

The open file descriptor n is associated with a terminal device; default n is 1.

-u file

file has its set-user-ID bit set.

-w file

file is writable.

-x file

file is executable.

-G file

file's group is the process's effective group ID.

-L file

file is a symbolic link.

-N file

file has been modified since its last time of access.

-O file

file's owner is the process's effective user ID.

-S file

file is a socket.

f1 -ef f2

Files f1 and f2 are linked (refer to same file through a hard link).

f1 -nt f2

File f1 is newer than f2.

f1 -ot f2

File f1 is older than f2.

String conditions

-n s1

String s1 has nonzero length.

-o s1

Shell option s1 is set. Shell options are described under the set built-in command.

-z s1

String s1 has 0 length.

s1 = s2

Strings s1 and s2 are identical.

s1 == s2

Strings s1 and s2 are identical.

s1 != s2

Strings s1 and s2 are not identical.

s1 < s2

String s1 is lower in the alphabet (or other sort in use) than s2. By default, the check is performed character-by-character against the ASCII character set.

s1 > s2

String s1 is higher in the alphabet (or other sort in use) than s2.

string

string is not null.

Integer comparisons

n1 -eq n2

n1 equals n2.

n1 -ge n2

n1 is greater than or equal to n2.

n1 -gt n2

n1 is greater than n2.

n1 -le n2

n1 is less than or equal to n2.

n1 -lt n2

n1 is less than n2.

n1 -ne n2

n1 does not equal n2.

Combined forms

! condition

True if condition is false.

condition1 -a condition2

True if both conditions are true.

condition1 -o condition2

True if either condition is true.

Examples

Each of the following examples shows the first line of various statements that might use a test condition:

while test $# -gt 0            While there are arguments . . .
while [ -n "$1" ]              While the first argument is nonempty . . .
if [ $count -lt 10 ]           If $count is less than 10 . . .
if [ -d RCS ]                  If the RCS directory exists . . .
if [ "$answer" != "y" ]        If the answer is not y . . .
if [ ! -r "$1" -o ! -f "$1" ]  If the first argument is not a
               readable file or a regular file . . .

Option

-l

List signals.

Signals

Signals are listed along with what triggers them.

0

Exit from shell (usually when shell script finishes).

1

Hang up (usually logout).

2

Interrupt (usually through Ctrl-C).

3

Quit.

4

Illegal instruction.

5

Trace trap.

6

Abort.

7

Unused.

8

Floating-point exception.

9

Termination.

10

User-defined.

11

Reference to invalid memory.

12

User-defined.

13

Write to a pipe without a process to read it.

14

Alarm timeout.

15

Software termination (usually via kill).

16

Unused.

17

Termination of child process.

18

Continue (if stopped).

19

Stop process.

20

Process suspended (usually through Ctrl-Z).

21

Background process has tty input.

22

Background process has tty output.

23

Unused.

24

Unused.

25

Unused.

26

Unused.

27

Unused.

28

Unused.

29

I/O possible on a channel.

Examples

trap "" 2     Ignore signal 2 (interrupts)
trap 2        Obey interrupts again

trap "rm -f $tmp; exit" 0 1 2 15

--

Consider all subsequent strings to be arguments, not options.

-a, -all

Print all occurrences of command, not just that which would be invoked.

-p, -path

Print the hashed value of command, which may differ from the first appearance of command in the PATH.

-t, -type

Determine and state if command is an alias, keyword, function, built-in, or file.

Example

$ type mv read
mv is /bin/mv
read is a shell built-in

Options

--

Consider all subsequent strings to be arguments, not options.

-a

Print all current limits.

-H

Hard resource limit.

-S

Soft resource limit.

Specific limits

These options limit specific resource sizes.

-c

Core files.

-d

Size of processes' data segments.

-f

Size of shell-created files.

-l

Size of memory that the process can lock.

-m

Resident set size.

-n

Number of file descriptors. On many systems, this cannot be set.

-p

Pipe size, measured in blocks of 512 bytes.

-s

Stack size.

-t

Amount of CPU time, counted in seconds.

-u

Number of processes per user.

-v

Virtual memory used by shell.

Options

-p

Display mask within an umask command so that a caller can read and execute it.

-S

Display umask symbolically, rather than in octal.

Option

-a

Remove all aliases.

Options

-f

Expect name to refer to a function.

-v

Expect name to refer to a variable (default).