|
Hopefully, this page is exactly what you are looking for, but if not, you can always find further assistance on Unix/Linux Forum!
User Commands BASH(1)
NAME
bash - GNU Bourne-Again SHell
SYNOPSIS
bash [options] [file]
COPYRIGHT
Bash is Copyright (C) 1989-2004 by the Free Software Founda-
tion, Inc.
DESCRIPTION
Bash is an sh-compatible command language interpreter that
executes commands read from the standard input or from a
file. Bash also incorporates useful features from the Korn
and C shells (ksh and csh).
Bash is intended to be a conformant implementation of the
IEEE POSIX Shell and Tools specification (IEEE Working Group
1003.2).
OPTIONS
In addition to the single-character shell options documented
in the description of the set builtin command, bash inter-
prets the following options when it is invoked:
-c string If the -c option is present, then commands are
read from string. If there are arguments after
the string, they are assigned to the positional
parameters, starting with $0.
-i If the -i option is present, the shell is interac-
tive.
-l Make bash act as if it had been invoked as a login
shell (see INVOCATION below).
-r If the -r option is present, the shell becomes
restricted (see RESTRICTED SHELL below).
-s If the -s option is present, or if no arguments
remain after option processing, then commands are
read from the standard input. This option allows
the positional parameters to be set when invoking
an interactive shell.
-D A list of all double-quoted strings preceded by $
is printed on the standard ouput. These are the
strings that are subject to language translation
when the current locale is not C or POSIX. This
implies the -n option; no commands will be exe-
cuted.
[-+]O [shopt_option]
shopt_option is one of the shell options accepted
by the shopt builtin (see SHELL BUILTIN COMMANDS
below). If shopt_option is present, -O sets the
value of that option; +O unsets it. If
shopt_option is not supplied, the names and values
GNU Bash-3.0 Last change: 2004 June 26 1
User Commands BASH(1)
of the shell options accepted by shopt are printed
on the standard output. If the invocation option
is +O, the output is displayed in a format that
may be reused as input.
-- A -- signals the end of options and disables
further option processing. Any arguments after
the -- are treated as filenames and arguments. An
argument of - is equivalent to --.
Bash also interprets a number of multi-character options.
These options must appear on the command line before the
single-character options to be recognized.
--debugger
Arrange for the debugger profile to be executed before
the shell starts. Turns on extended debugging mode
(see the description of the extdebug option to the
shopt builtin below) and shell function tracing (see
the description of the -o functrace option to the set
builtin below).
--dump-po-strings
Equivalent to -D, but the output is in the GNU gettext
po (portable object) file format.
--dump-strings
Equivalent to -D.
--help
Display a usage message on standard output and exit
successfully.
--init-file file
--rcfile file
Execute commands from file instead of the standard per-
sonal initialization file ~/.bashrc if the shell is
interactive (see INVOCATION below).
--login
Equivalent to -l.
--noediting
Do not use the GNU readline library to read command
lines when the shell is interactive.
--noprofile
Do not read either the system-wide startup file
/etc/profile or any of the personal initialization
files ~/.bash_profile, ~/.bash_login, or ~/.profile.
By default, bash reads these files when it is invoked
as a login shell (see INVOCATION below).
--norc
Do not read and execute the personal initialization
file ~/.bashrc if the shell is interactive. This
option is on by default if the shell is invoked as sh.
GNU Bash-3.0 Last change: 2004 June 26 2
User Commands BASH(1)
--posix
Change the behavior of bash where the default operation
differs from the POSIX 1003.2 standard to match the
standard (posix mode).
--restricted
The shell becomes restricted (see RESTRICTED SHELL
below).
--verbose
Equivalent to -v.
--version
Show version information for this instance of bash on
the standard output and exit successfully.
ARGUMENTS
If arguments remain after option processing, and neither the
-c nor the -s option has been supplied, the first argument
is assumed to be the name of a file containing shell com-
mands. If bash is 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. Bash's exit status is the exit
status of the last command executed in the script. If no
commands are executed, the exit status is 0. An attempt is
first made to open the file in the current directory, and,
if no file is found, then the shell searches the directories
in PATH for the script.
INVOCATION
A login shell is one whose first character of argument zero
is a -, or one started with the --login option.
An interactive shell is one started without non-option argu-
ments and without the -c option whose standard input and
error are both connected to terminals (as determined by
isatty(3)), or one started with the -i option. PS1 is set
and $- includes i if bash is interactive, allowing a shell
script or a startup file to test this state.
The following paragraphs describe how bash executes its
startup files. If any of the files exist but cannot be
read, bash reports an error. Tildes are expanded in file
names as described below under Tilde Expansion in the EXPAN-
SION section.
When bash is invoked as an interactive login shell, or as a
non-interactive shell with the --login option, it first
reads and executes commands from the file /etc/profile, if
that file exists. After reading that file, it looks for
~/.bash_profile, ~/.bash_login, and ~/.profile, in that
GNU Bash-3.0 Last change: 2004 June 26 3
User Commands BASH(1)
order, and reads and executes commands from the first one
that exists and is readable. The --noprofile option may be
used when the shell is started to inhibit this behavior.
When a login shell exits, bash reads and executes commands
from the file ~/.bash_logout, if it exists.
When an interactive shell that is not a login shell is
started, bash reads and executes commands from ~/.bashrc, if
that file exists. This may be inhibited by using the --norc
option. The --rcfile file option will force bash to read
and execute commands from file instead of ~/.bashrc.
When bash is started non-interactively, to run a shell
script, for example, it looks for the variable BASH_ENV in
the environment, expands its value if it appears there, and
uses the expanded value as the name of a file to read and
execute. Bash behaves as if the following command were exe-
cuted:
if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
but the value of the PATH variable is not used to search for
the file name.
If bash is invoked with the name sh, it tries to mimic the
startup behavior of historical versions of sh as closely as
possible, while conforming to the POSIX standard as well.
When invoked as an interactive login shell, or a non-
interactive shell with the --login option, it first attempts
to read and execute commands from /etc/profile and ~/.pro-
file, in that order. The --noprofile option may be used to
inhibit this behavior. When invoked as an interactive shell
with the name sh, bash looks for the variable ENV, expands
its value if it is defined, and uses the expanded value as
the name of a file to read and execute. Since a shell
invoked as sh does not attempt to read and execute commands
from any other startup files, the --rcfile option has no
effect. A non-interactive shell invoked with the name sh
does not attempt to read any other startup files. When
invoked as sh, bash enters posix mode after the startup
files are read.
When bash is started in posix mode, as with the --posix com-
mand line option, it follows the POSIX standard for startup
files. In this mode, interactive shells expand the ENV
variable and commands are read and executed from the file
whose name is the expanded value. No other startup files
are read.
Bash attempts to determine when it is being run by the
remote shell daemon, usually rshd. If bash determines it is
being run by rshd, it reads and executes commands from
~/.bashrc, if that file exists and is readable. It will not
GNU Bash-3.0 Last change: 2004 June 26 4
User Commands BASH(1)
do this if invoked as sh. The --norc option may be used to
inhibit this behavior, and the --rcfile option may be used
to force another file to be read, but rshd does not gen-
erally invoke the shell with those options or allow them to
be specified.
If the shell is started with the effective user (group) id
not equal to the real user (group) id, and the -p option is
not supplied, no startup files are read, shell functions are
not inherited from the environment, the SHELLOPTS variable,
if it appears in the environment, is ignored, and the effec-
tive user id is set to the real user id. If the -p option
is supplied at invocation, the startup behavior is the same,
but the effective user id is not reset.
DEFINITIONS
The following definitions are used throughout the rest of
this document.
blank
A space or tab.
word A sequence of characters considered as a single unit by
the shell. Also known as a token.
name A word consisting only of alphanumeric characters and
underscores, and beginning with an alphabetic character
or an underscore. Also referred to as an identifier.
metacharacter
A character that, when unquoted, separates words. One
of the following:
| & ; ( ) < > space tab
control operator
A token that performs a control function. It is one of
the following symbols:
|| & && ; ;; ( ) | <newline>
RESERVED WORDS
Reserved words are words that have a special meaning to the
shell. The following words are recognized as reserved when
unquoted and either the first word of a simple command (see
SHELL GRAMMAR below) or the third word of a case or for com-
mand:
! case do done elif else esac fi for function if in select
then until while { } time [[ ]]
SHELL GRAMMAR
Simple Commands
A simple command is a sequence of optional variable assign-
ments followed by blank-separated words and redirections,
and terminated by a control operator. The first word speci-
fies the command to be executed, and is passed as argument
zero. The remaining words are passed as arguments to the
invoked command.
GNU Bash-3.0 Last change: 2004 June 26 5
User Commands BASH(1)
The return value of a simple command is its exit status, or
128+n if the command is terminated by signal n.
Pipelines
A pipeline is a sequence of one or more commands separated
by the character |. The format for a pipeline is:
[time [-p]] [ ! ] command [ | command2 ... ]
The standard output of command is connected via a pipe to
the standard input of command2. This connection is per-
formed before any redirections specified by the command (see
REDIRECTION below).
The return status of a pipeline is the exit status of the
last command, unless the pipefail option is enabled. If
pipefail is enabled, the pipeline's return status is the
value of the last (rightmost) command to exit with a non-
zero status, or zero if all commands exit successfully. If
the reserved word ! precedes a pipeline, the exit status of
that pipeline is the logical negation of the exit status as
described above. The shell waits for all commands in the
pipeline to terminate before returning a value.
If the time reserved word precedes a pipeline, the elapsed
as well as user and system time consumed by its execution
are reported when the pipeline terminates. The -p option
changes the output format to that specified by POSIX. The
TIMEFORMAT variable may be set to a format string that
specifies how the timing information should be displayed;
see the description of TIMEFORMAT under Shell Variables
below.
Each command in a pipeline is executed as a separate process
(i.e., in a subshell).
Lists
A list is a sequence of one or more pipelines separated by
one of the operators ;, &, &&, or ||, and optionally ter-
minated by one of ;, &, or <newline>.
Of these list operators, && and || have equal precedence,
followed by ; and &, which have equal precedence.
A sequence of one or more newlines may appear in a list
instead of a semicolon to delimit commands.
If a command is terminated by the control operator &, the
shell executes the command in the background in a subshell.
The shell does not wait for the command to finish, and the
return status is 0. Commands separated by a ; are executed
sequentially; the shell waits for each command to terminate
GNU Bash-3.0 Last change: 2004 June 26 6
User Commands BASH(1)
in turn. The return status is the exit status of the last
command executed.
The control operators && and || denote AND lists and OR
lists, respectively. An AND list has the form
command1 && command2
command2 is executed if, and only if, command1 returns an
exit status of zero.
An OR list has the form
command1 || command2
command2 is executed if and only if command1 returns a non-
zero exit status. The return status of AND and OR lists is
the exit status of the last command executed in the list.
Compound Commands
A compound command is one of the following:
(list)
list is executed in a subshell environment (see COMMAND
EXECUTION ENVIRONMENT below). Variable assignments and
builtin commands that affect the shell's environment do
not remain in effect after the command completes. The
return status is the exit status of list.
{ list; }
list is simply executed in the current shell environ-
ment. list must be terminated with a newline or semi-
colon. This is known as a group command. The return
status is the exit status of list. Note that unlike
the metacharacters ( and ), { and } are reserved words
and must occur where a reserved word is permitted to be
recognized. Since they do not cause a word break, they
must be separated from list by whitespace.
((expression))
The expression is evaluated according to the rules
described below under ARITHMETIC EVALUATION. If the
value of the expression is non-zero, the return status
is 0; otherwise the return status is 1. This is
exactly equivalent to let "expression".
[[ expression ]]
Return a status of 0 or 1 depending on the evaluation
of the conditional expression expression. Expressions
are composed of the primaries described below under
CONDITIONAL EXPRESSIONS. Word splitting and pathname
expansion are not performed on the words between the [[
GNU Bash-3.0 Last change: 2004 June 26 7
User Commands BASH(1)
and ]]; tilde expansion, parameter and variable expan-
sion, arithmetic expansion, command substitution, pro-
cess substitution, and quote removal are performed.
Conditional operators such as -f must be unquoted to be
recognized as primaries.
When the == and != operators are used, the string to
the right of the operator is considered a pattern and
matched according to the rules described below under
Pattern Matching. The return value is 0 if the string
matches or does not match the pattern, respectively,
and 1 otherwise. Any part of the pattern may be quoted
to force it to be matched as a string.
An additional binary operator, =~, is available, with
the same precedence as == and !=. When it is used, the
string to the right of the operator is considered an
extended regular expression and matched accordingly (as
in regex(3)). The return value is 0 if the string
matches the pattern, and 1 otherwise. If the regular
expression is syntactically incorrect, the conditional
expression's return value is 2. If the shell option
nocaseglob is enabled, the match is performed without
regard to the case of alphabetic characters. Sub-
strings matched by parenthesized subexpressions within
the regular expression are saved in the array variable
BASH_REMATCH. The element of BASH_REMATCH with index 0
is the portion of the string matching the entire regu-
lar expression. The element of BASH_REMATCH with index
n is the portion of the string matching the nth
parenthesized subexpression.
Expressions may be combined using the following opera-
tors, listed in decreasing order of precedence:
( expression )
Returns the value of expression. This may be used
to override the normal precedence of operators.
! expression
True if expression is false.
expression1 && expression2
True if both expression1 and expression2 are true.
expression1 || expression2
True if either expression1 or expression2 is true.
The && and || operators do not evaluate expression2 if
the value of expression1 is sufficient to determine the
return value of the entire conditional expression.
for name [ in word ] ; do list ; done
The list of words following in is expanded, generating
a list of items. The variable name is set to each
GNU Bash-3.0 Last change: 2004 June 26 8
User Commands BASH(1)
element of this list in turn, and list is executed each
time. If the in word is omitted, the for command exe-
cutes list once for each positional parameter that is
set (see PARAMETERS below). The return status is the
exit status of the last command that executes. If the
expansion of the items following in results in an empty
list, no commands are executed, and the return status
is 0.
for (( expr1 ; expr2 ; expr3 )) ; do list ; done
First, the arithmetic expression expr1 is evaluated
according to the rules described below under ARITHMETIC
EVALUATION. The arithmetic expression expr2 is then
evaluated repeatedly until it evaluates to zero. Each
time expr2 evaluates to a non-zero value, list is exe-
cuted and the arithmetic expression expr3 is evaluated.
If any expression is omitted, it behaves as if it
evaluates to 1. The return value is the exit status of
the last command in list that is executed, or false if
any of the expressions is invalid.
select name [ in word ] ; do list ; done
The list of words following in is expanded, generating
a list of items. The set of expanded words is printed
on the standard error, each preceded by a number. If
the in word is omitted, the positional parameters are
printed (see PARAMETERS below). The PS3 prompt is then
displayed and a line read from the standard input. If
the line consists of a number corresponding to one of
the displayed words, then the value of name is set to
that word. If the line is empty, the words and prompt
are displayed again. If EOF is read, the command com-
pletes. Any other value read causes name to be set to
null. The line read is saved in the variable REPLY.
The list is executed after each selection until a break
command is executed. The exit status of select is the
exit status of the last command executed in list, or
zero if no commands were executed.
case word in [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac
A case command first expands word, and tries to match
it against each pattern in turn, using the same match-
ing rules as for pathname expansion (see Pathname
Expansion below). When a match is found, the
corresponding list is executed. After the first match,
no subsequent matches are attempted. The exit status
is zero if no pattern matches. Otherwise, it is the
exit status of the last command executed in list.
fi
if list; then list; [ elif list; then list; ] ... [ else list; ]
The if list is executed. If its exit status is zero,
GNU Bash-3.0 Last change: 2004 June 26 9
User Commands BASH(1)
the then list is executed. Otherwise, each elif list
is executed in turn, and if its exit status is zero,
the corresponding then list is executed and the command
completes. Otherwise, the else list is executed, if
present. The exit status is the exit status of the
last command executed, or zero if no condition tested
true.
while list; do list; done
until list; do list; done
The while command continuously executes the do list as
long as the last command in list returns an exit status
of zero. The until command is identical to the while
command, except that the test is negated; the do list
is executed as long as the last command in list returns
a non-zero exit status. The exit status of the while
and until commands is the exit status of the last do
list command executed, or zero if none was executed.
Shell Function Definitions
A shell function is an object that is called like a simple
command and executes a compound command with a new set of
positional parameters. Shell functions are declared as fol-
lows:
[ function ] name () compound-command [redirection]
This defines a function named name. The reserved word
function is optional. If the function reserved word is
supplied, the parentheses are optional. The body of
the function is the compound command compound-command
(see Compound Commands above). That command is usually
a list of commands between { and }, but may be any com-
mand listed under Compound Commands above.
compound-command is executed whenever name is specified
as the name of a simple command. Any redirections (see
REDIRECTION below) specified when a function is defined
are performed when the function is executed. The exit
status of a function definition is zero unless a syntax
error occurs or a readonly function with the same name
already exists. When executed, the exit status of a
function is the exit status of the last command exe-
cuted in the body. (See FUNCTIONS below.)
COMMENTS
In a non-interactive shell, or an interactive shell in which
the interactive_comments option to the shopt builtin is
enabled (see SHELL BUILTIN COMMANDS below), a word beginning
with # causes that word and all remaining characters on that
line to be ignored. An interactive shell without the
interactive_comments option enabled does not allow comments.
The interactive_comments option is on by default in interac-
tive shells.
GNU Bash-3.0 Last change: 2004 June 26 10
User Commands BASH(1)
QUOTING
Quoting is used to remove the special meaning of certain
characters or words to the shell. Quoting can be used to
disable special treatment for special characters, to prevent
reserved words from being recognized as such, and to prevent
parameter expansion.
Each of the metacharacters listed above under DEFINITIONS
has special meaning to the shell and must be quoted if it is
to represent itself.
When the command history expansion facilities are being
used, the history expansion character, usually !, must be
quoted to prevent history expansion.
There are three quoting mechanisms: the escape character,
single quotes, and double quotes.
A non-quoted backslash (\) is the escape character. It
preserves the literal value of the next character that fol-
lows, with the exception of <newline>. If a \<newline> pair
appears, and the backslash is not itself quoted, the \<new-
line> is treated as a line continuation (that is, it is
removed from the input stream and effectively ignored).
Enclosing characters in single quotes preserves the literal
value of each character within the quotes. A single quote
may not occur between single quotes, even when preceded by a
backslash.
Enclosing characters in double quotes preserves the literal
value of all characters within the quotes, with the excep-
tion of $, `, and \. The characters $ and ` retain their
special meaning within double quotes. The backslash retains
its special meaning only when followed by one of the follow-
ing characters: $, `, ", \, or <newline>. A double quote
may be quoted within double quotes by preceding it with a
backslash. When command history is being used, the double
quote may not be used to quote the history expansion charac-
ter.
The special parameters * and @ have special meaning when in
double quotes (see PARAMETERS below).
Words of the form $'string' are treated specially. The word
expands to string, with backslash-escaped characters
replaced as specifed by the ANSI C standard. Backslash
escape sequences, if present, are decoded as follows:
\a alert (bell)
\b backspace
\e an escape character
\f form feed
GNU Bash-3.0 Last change: 2004 June 26 11
User Commands BASH(1)
\n new line
\r carriage return
\t horizontal tab
\v vertical tab
\\ backslash
\' single quote
\nnn the eight-bit character whose value is the octal
value nnn (one to three digits)
\xHH the eight-bit character whose value is the hexade-
cimal value HH (one or two hex digits)
\cx a control-x character
The expanded result is single-quoted, as if the dollar sign
had not been present.
A double-quoted string preceded by a dollar sign ($) will
cause the string to be translated according to the current
locale. If the current locale is C or POSIX, the dollar
sign is ignored. If the string is translated and replaced,
the replacement is double-quoted.
PARAMETERS
A parameter is an entity that stores values. It can be a
name, a number, or one of the special characters listed
below under Special Parameters. A variable is a parameter
denoted by a name. A variable has a value and zero or more
attributes. Attributes are assigned using the declare buil-
tin command (see declare below in SHELL BUILTIN COMMANDS).
A parameter is set if it has been assigned a value. The
null string is a valid value. Once a variable is set, it
may be unset only by using the unset builtin command (see
SHELL BUILTIN COMMANDS below).
A variable may be assigned to by a statement of the form
name=[value]
If value is not given, the variable is assigned the null
string. All values undergo tilde expansion, parameter and
variable expansion, command substitution, arithmetic expan-
sion, and quote removal (see EXPANSION below). If the vari-
able has its integer attribute set, then value is evaluated
as an arithmetic expression even if the $((...)) expansion
is not used (see Arithmetic Expansion below). Word split-
ting is not performed, with the exception of "$@" as
explained below under Special Parameters. Pathname expan-
sion is not performed. Assignment statements may also
appear as arguments to the alias, declare, typeset, export,
readonly, and local builtin commands.
GNU Bash-3.0 Last change: 2004 June 26 12
User Commands BASH(1)
Positional Parameters
A positional parameter is a parameter denoted by one or more
digits, other than the single digit 0. Positional parame-
ters are assigned from the shell's arguments when it is
invoked, and may be reassigned using the set builtin com-
mand. Positional parameters may not be assigned to with
assignment statements. The positional parameters are tem-
porarily replaced when a shell function is executed (see
FUNCTIONS below).
When a positional parameter consisting of more than a single
digit is expanded, it must be enclosed in braces (see EXPAN-
SION below).
Special Parameters
The shell treats several parameters specially. These param-
eters may only be referenced; assignment to them is not
allowed.
* Expands to the positional parameters, starting from
one. When the expansion occurs within double quotes,
it expands to a single word with the value of each
parameter separated by the first character of the IFS
special variable. That is, "$*" is equivalent to
"$1c$2c...", where c is the first character of the
value of the IFS variable. If IFS is unset, the param-
eters are separated by spaces. If IFS is null, the
parameters are joined without intervening separators.
@ Expands to the positional parameters, starting from
one. When the expansion occurs within double quotes,
each parameter expands to a separate word. That is,
"$@" is equivalent to "$1" "$2" ... When there are no
positional parameters, "$@" and $@ expand to nothing
(i.e., they are removed).
# Expands to the number of positional parameters in
decimal.
? Expands to the status of the most recently executed
foreground pipeline.
- Expands to the current option flags as specified upon
invocation, by the set builtin command, or those set by
the shell itself (such as the -i option).
$ Expands to the process ID of the shell. In a () sub-
shell, it expands to the process ID of the current
shell, not the subshell.
! Expands to the process ID of the most recently executed
background (asynchronous) command.
0 Expands to the name of the shell or shell script. This
is set at shell initialization. If bash is invoked
with a file of commands, $0 is set to the name of that
file. If bash is started with the -c option, then $0
is set to the first argument after the string to be
executed, if one is present. Otherwise, it is set to
the file name used to invoke bash, as given by argument
GNU Bash-3.0 Last change: 2004 June 26 13
User Commands BASH(1)
zero.
_ At shell startup, set to the absolute file name of the
shell or shell script being executed as passed in the
argument list. Subsequently, expands to the last argu-
ment to the previous command, after expansion. Also
set to the full file name of each command executed and
placed in the environment exported to that command.
When checking mail, this parameter holds the name of
the mail file currently being checked.
Shell Variables
The following variables are set by the shell:
BASH Expands to the full file name used to invoke this
instance of bash.
BASH_ARGC
An array variable whose values are the number of param-
eters in each frame of the current bash execution call
stack. The number of parameters to the current subrou-
tine (shell function or script executed with . or
source) is at the top of the stack. When a subroutine
is executed, the number of parameters passed is pushed
onto BASH_ARGC.
BASH_ARGV
An array variable containing all of the parameters in
the current bash execution call stack. The final
parameter of the last subroutine call is at the top of
the stack; the first parameter of the initial call is
at the bottom. When a subroutine is executed, the
parameters supplied are pushed onto BASH_ARGV.
BASH_COMMAND
The command currently being executed or about to be
executed, unless the shell is executing a command as
the result of a trap, in which case it is the command
executing at the time of the trap.
BASH_EXECUTION_STRING
The command argument to the -c invocation option.
BASH_LINENO
An array variable whose members are the line numbers in
source files corresponding to each member of
@var{FUNCNAME}. ${BASH_LINENO[$i]} is the line number
in the source file where ${FUNCNAME[$i + 1]} was
called. The corresponding source file name is
${BASH_SOURCE[$i + 1]}. Use LINENO to obtain the
current line number.
BASH_REMATCH
An array variable whose members are assigned by the =~
binary operator to the [[ conditional command. The
element with index 0 is the portion of the string
matching the entire regular expression. The element
with index n is the portion of the string matching the
nth parenthesized subexpression. This variable is
GNU Bash-3.0 Last change: 2004 June 26 14
User Commands BASH(1)
read-only.
BASH_SOURCE
An array variable whose members are the source
filenames corresponding to the elements in the FUNCNAME
array variable.
BASH_SUBSHELL
Incremented by one each time a subshell or subshell
environment is spawned. The initial value is 0.
BASH_VERSINFO
A readonly array variable whose members hold version
information for this instance of bash. The values
assigned to the array members are as follows:
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.
BASH_VERSION
Expands to a string describing the version of this
instance of bash.
COMP_CWORD
An index into ${COMP_WORDS} of the word containing the
current cursor position. This variable is available
only in shell functions invoked by the programmable
completion facilities (see Programmable Completion
below).
COMP_LINE
The current command line. This variable is available
only in shell functions and external commands invoked
by the programmable completion facilities (see Pro-
grammable Completion below).
COMP_POINT
The index of the current cursor position relative to
the beginning of the current command. If the current
cursor position is at the end of the current command,
the value of this variable is equal to ${#COMP_LINE}.
This variable is available only in shell functions and
external commands invoked by the programmable comple-
tion facilities (see Programmable Completion below).
COMP_WORDBREAKS
The set of characters that the Readline library treats
as word separators when performing word completion. If
COMP_WORDBREAKS is unset, it loses its special
GNU Bash-3.0 Last change: 2004 June 26 15
User Commands BASH(1)
properties, even if it is subsequently reset.
COMP_WORDS
An array variable (see Arrays below) consisting of the
individual words in the current command line. This
variable is available only in shell functions invoked
by the programmable completion facilities (see Pro-
grammable Completion below).
DIRSTACK
An array variable (see Arrays below) containing the
current contents of the directory stack. Directories
appear in the stack in the order they are displayed by
the dirs builtin. Assigning to members of this array
variable may be used to modify directories already in
the stack, but the pushd and popd builtins must be used
to add and remove directories. Assignment to this
variable will not change the current directory. If
DIRSTACK is unset, it loses its special properties,
even if it is subsequently reset.
EUID Expands to the effective user ID of the current user,
initialized at shell startup. This variable is
readonly.
FUNCNAME
An array variable containing the names of all shell
functions currently in the execution call stack. The
element with index 0 is the name of any currently-
executing shell function. The bottom-most element is
"main". This variable exists only when a shell func-
tion is executing. Assignments to FUNCNAME have no
effect and return an error status. If FUNCNAME is
unset, it loses its special properties, even if it is
subsequently reset.
GROUPS
An array variable containing the list of groups of
which the current user is a member. Assignments to
GROUPS have no effect and return an error status. If
GROUPS is unset, it loses its special properties, even
if it is subsequently reset.
HISTCMD
The history number, or index in the history list, of
the current command. If HISTCMD is unset, it loses its
special properties, even if it is subsequently reset.
HOSTNAME
Automatically set to the name of the current host.
HOSTTYPE
GNU Bash-3.0 Last change: 2004 June 26 16
User Commands BASH(1)
Automatically set to a string that uniquely describes
the type of machine on which bash is executing. The
default is system-dependent.
LINENO
Each time this parameter is referenced, the shell sub-
stitutes a decimal number representing the current
sequential line number (starting with 1) within a
script or function. When not in a script or function,
the value substituted is not guaranteed to be meaning-
ful. If LINENO is unset, it loses its special proper-
ties, even if it is subsequently reset.
MACHTYPE
Automatically set to a string that fully describes the
system type on which bash is executing, in the standard
GNU cpu-company-system format. The default is system-
dependent.
OLDPWD
The previous working directory as set by the cd com-
mand.
OPTARG
The value of the last option argument processed by the
getopts builtin command (see SHELL BUILTIN COMMANDS
below).
OPTIND
The index of the next argument to be processed by the
getopts builtin command (see SHELL BUILTIN COMMANDS
below).
OSTYPE
Automatically set to a string that describes the
operating system on which bash is executing. The
default is system-dependent.
PIPESTATUS
An array variable (see Arrays below) containing a list
of exit status values from the processes in the most-
recently-executed foreground pipeline (which may con-
tain only a single command).
PPID The process ID of the shell's parent. This variable is
readonly.
PWD The current working directory as set by the cd command.
RANDOM
Each time this parameter is referenced, a random
integer between 0 and 32767 is generated. The sequence
GNU Bash-3.0 Last change: 2004 June 26 17
User Commands BASH(1)
of random numbers may be initialized by assigning a
value to RANDOM. If RANDOM is unset, it loses its spe-
cial properties, even if it is subsequently reset.
REPLY
Set to the line of input read by the read builtin com-
mand when no arguments are supplied.
SECONDS
Each time this parameter is referenced, the number of
seconds since shell invocation is returned. If a value
is assigned to SECONDS, the value returned upon subse-
quent references is the number of seconds since the
assignment plus the value assigned. If SECONDS is
unset, it loses its special properties, even if it is
subsequently reset.
SHELLOPTS
A colon-separated list of enabled shell options. Each
word in the list is a valid argument for the -o option
to the set builtin command (see SHELL BUILTIN COMMANDS
below). The options appearing in SHELLOPTS are those
reported as on by set -o. If this variable is in the
environment when bash starts up, each shell option in
the list will be enabled before reading any startup
files. This variable is read-only.
SHLVL
Incremented by one each time an instance of bash is
started.
UID Expands to the user ID of the current user, initialized
at shell startup. This variable is readonly.
The following variables are used by the shell. In some
cases, bash assigns a default value to a variable; these
cases are noted below.
BASH_ENV
If this parameter is set when bash is executing a shell
script, its value is interpreted as a filename contain-
ing commands to initialize the shell, as in ~/.bashrc.
The value of BASH_ENV is subjected to parameter expan-
sion, command substitution, and arithmetic expansion
before being interpreted as a file name. PATH is not
used to search for the resultant file name.
CDPATH
The search path for the cd command. This is a colon-
separated list of directories in which the shell looks
for destination directories specified by the cd com-
mand. A sample value is ".:~:/usr".
COLUMNS
GNU Bash-3.0 Last change: 2004 June 26 18
User Commands BASH(1)
Used by the select builtin command to determine the
terminal width when printing selection lists. Automat-
ically set upon receipt of a SIGWINCH.
COMPREPLY
An array variable from which bash reads the possible
completions generated by a shell function invoked by
the programmable completion facility (see Programmable
Completion below).
EMACS
If bash finds this variable in the environment when the
shell starts with value "t", it assumes that the shell
is running in an emacs shell buffer and disables line
editing.
FCEDIT
The default editor for the fc builtin command.
FIGNORE
A colon-separated list of suffixes to ignore when per-
forming filename completion (see READLINE below). A
filename whose suffix matches one of the entries in
FIGNORE is excluded from the list of matched filenames.
A sample value is ".o:~".
GLOBIGNORE
A colon-separated list of patterns defining the set of
filenames to be ignored by pathname expansion. If a
filename matched by a pathname expansion pattern also
matches one of the patterns in GLOBIGNORE, it is
removed from the list of matches.
HISTCONTROL
A colon-separated list of values controlling how com-
mands are saved on the history list. If the list of
values includes ignorespace, lines which begin with a
space character are not saved in the history list. A
value of ignoredups causes lines matching the previous
history entry to not be saved. A value of ignoreboth
is shorthand for ignorespace and ignoredups. A value
of erasedups causes all previous lines matching the
current line to be removed from the history list before
that line is saved. Any value not in the above list is
ignored. If HISTCONTROL is unset, or does not include
a valid value, all lines read by the shell parser are
saved on the history list, subject to the value of HIS-
TIGNORE. The second and subsequent lines of a multi-
line compound command are not tested, and are added to
the history regardless of the value of HISTCONTROL.
HISTFILE
The name of the file in which command history is saved
(see HISTORY below). The default value is
~/.bash_history. If unset, the command history is not
saved when an interactive shell exits.
HISTFILESIZE
The maximum number of lines contained in the history
file. When this variable is assigned a value, the
GNU Bash-3.0 Last change: 2004 June 26 19
User Commands BASH(1)
history file is truncated, if necessary, to contain no
more than that number of lines. The default value is
500. The history file is also truncated to this size
after writing it when an interactive shell exits.
HISTIGNORE
A colon-separated list of patterns used to decide which
command lines should be saved on the history list.
Each pattern is anchored at the beginning of the line
and must match the complete line (no implicit `*' is
appended). Each pattern is tested against the line
after the checks specified by HISTCONTROL are applied.
In addition to the normal shell pattern matching char-
acters, `&' matches the previous history line. `&' may
be escaped using a backslash; the backslash is removed
before attempting a match. The second and subsequent
lines of a multi-line compound command are not tested,
and are added to the history regardless of the value of
HISTIGNORE.
HISTSIZE
The number of commands to remember in the command his-
tory (see HISTORY below). The default value is 500.
HISTTIMEFORMAT
If this variable is set and not null, its value is used
as a format string for strftime(3) to print the time
stamp associated with each history entry displayed by
the history builtin. If this variable is set, time
stamps are written to the history file so they may be
preserved across shell sessions.
HOME The home directory of the current user; the default
argument for the cd builtin command. The value of this
variable is also used when performing tilde expansion.
HOSTFILE
Contains the name of a file in the same format as
/etc/hosts that should be read when the shell needs to
complete a hostname. The list of possible hostname
completions may be changed while the shell is running;
the next time hostname completion is attempted after
the value is changed, bash adds the contents of the new
file to the existing list. If HOSTFILE is set, but has
no value, bash attempts to read /etc/hosts to obtain
the list of possible hostname completions. When HOST-
FILE is unset, the hostname list is cleared.
IFS The Internal Field Separator that is used for word
splitting after expansion and to split lines into words
with the read builtin command. The default value is
``<space><tab><newline>''.
IGNOREEOF
Controls the action of an interactive shell on receipt
of an EOF character as the sole input. If set, the
value is the number of consecutive EOF characters which
must be typed as the first characters on an input line
before bash exits. If the variable exists but does not
GNU Bash-3.0 Last change: 2004 June 26 20
User Commands BASH(1)
have a numeric value, or has no value, the default
value is 10. If it does not exist, EOF signifies the
end of input to the shell.
INPUTRC
The filename for the readline startup file, overriding
the default of ~/.inputrc (see READLINE below).
LANG Used to determine the locale category for any category
not specifically selected with a variable starting with
LC_.
LC_ALL
This variable overrides the value of LANG and any other
LC_ variable specifying a locale category.
LC_COLLATE
This variable determines the collation order used when
sorting the results of pathname expansion, and deter-
mines the behavior of range expressions, equivalence
classes, and collating sequences within pathname expan-
sion and pattern matching.
LC_CTYPE
This variable determines the interpretation of charac-
ters and the behavior of character classes within path-
name expansion and pattern matching.
LC_MESSAGES
This variable determines the locale used to translate
double-quoted strings preceded by a $.
LC_NUMERIC
This variable determines the locale category used for
number formatting.
LINES
Used by the select builtin command to determine the
column length for printing selection lists. Automati-
cally set upon receipt of a SIGWINCH.
MAIL If this parameter is set to a file name and the MAIL-
PATH variable is not set, bash informs the user of the
arrival of mail in the specified file.
MAILCHECK
Specifies how often (in seconds) bash checks for mail.
The default is 60 seconds. When it is time to check
for mail, the shell does so before displaying the pri-
mary prompt. If this variable is unset, or set to a
value that is not a number greater than or equal to
zero, the shell disables mail checking.
MAILPATH
A colon-separated list of file names to be checked for
mail. The message to be printed when mail arrives in a
particular file may be specified by separating the file
name from the message with a `?'. When used in the
text of the message, $_ expands to the name of the
current mailfile. Example:
MAILPATH='/var/mail/bfox?"You have
mail":~/shell-mail?"$_ has mail!"'
GNU Bash-3.0 Last change: 2004 June 26 21
User Commands BASH(1)
Bash supplies a default value for this variable, but
the location of the user mail files that it uses is
system dependent (e.g., /var/mail/$USER).
OPTERR
If set to the value 1, bash displays error messages
generated by the getopts builtin command (see SHELL
BUILTIN COMMANDS below). OPTERR is initialized to 1
each time the shell is invoked or a shell script is
executed.
PATH The search path for commands. It is a colon-separated
list of directories in which the shell looks for com-
mands (see COMMAND EXECUTION below). A zero-length
(null) directory name in the value of PATH indicates
the current directory. A null directory name may
appear as two adjacent colons, or as an initial or
trailing colon. The default path is system-dependent,
and is set by the administrator who installs bash. A
common value is
``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin''.
POSIXLY_CORRECT
If this variable is in the environment when bash
starts, the shell enters posix mode before reading the
startup files, as if the --posix invocation option had
been supplied. If it is set while the shell is run-
ning, bash enables posix mode, as if the command set -o
posix had been executed.
PROMPT_COMMAND
If set, the value is executed as a command prior to
issuing each primary prompt.
PS1 The value of this parameter is expanded (see PROMPTING
below) and used as the primary prompt string. The
default value is ``\s-\v\$ ''.
PS2 The value of this parameter is expanded as with PS1 and
used as the secondary prompt string. The default is
``> ''.
PS3 The value of this parameter is used as the prompt for
the select command (see SHELL GRAMMAR above).
PS4 The value of this parameter is expanded as with PS1 and
the value is printed before each command bash displays
during an execution trace. The first character of PS4
is replicated multiple times, as necessary, to indicate
multiple levels of indirection. The default is ``+ ''.
SHELL
The full pathname to the shell is kept in this environ-
ment variable. If it is not set when the shell starts,
bash assigns to it the full pathname of the current
user's login shell.
TIMEFORMAT
The value of this parameter is used as a format string
specifying how the timing information for pipelines
prefixed with the time reserved word should be
displayed. The % character introduces an escape
GNU Bash-3.0 Last change: 2004 June 26 22
User Commands BASH(1)
sequence that is expanded to a time value or other
information. The escape sequences and their meanings
are as follows; the braces denote optional portions.
%% A literal %.
%[p][l]R The elapsed time in seconds.
%[p][l]U The number of CPU seconds spent in user mode.
%[p][l]S The number of CPU seconds spent in system
mode.
%P The CPU percentage, computed as (%U + %S) /
%R.
The optional p is a digit specifying the precision, the
number of fractional digits after a decimal point. A
value of 0 causes no decimal point or fraction to be
output. At most three places after the decimal point
may be specified; values of p greater than 3 are
changed to 3. If p is not specified, the value 3 is
used.
The optional l specifies a longer format, including
minutes, of the form MMmSS.FFs. The value of p deter-
mines whether or not the fraction is included.
If this variable is not set, bash acts as if it had the
value $'\nreal\t%3lR\nuser\t%3lU\nsys%3lS'. If the
value is null, no timing information is displayed. A
trailing newline is added when the format string is
displayed.
TMOUT
If set to a value greater than zero, TMOUT is treated
as the default timeout for the read builtin. The
select command terminates if input does not arrive
after TMOUT seconds when input is coming from a termi-
nal. In an interactive shell, the value is interpreted
as the number of seconds to wait for input after issu-
ing the primary prompt. Bash terminates after waiting
for that number of seconds if input does not arrive.
auto_resume
This variable controls how the shell interacts with the
user and job control. If this variable is set, single
word simple commands without redirections are treated
as candidates for resumption of an existing stopped
job. There is no ambiguity allowed; if there is more
than one job beginning with the string typed, the job
most recently accessed is selected. The name of a
stopped job, in this context, is the command line used
to start it. If set to the value exact, the string
supplied must match the name of a stopped job exactly;
if set to substring, the string supplied needs to match
a substring of the name of a stopped job. The
GNU Bash-3.0 Last change: 2004 June 26 23
User Commands BASH(1)
substring value provides functionality analogous to the
%? job identifier (see JOB CONTROL below). If set to
any other value, the supplied string must be a prefix
of a stopped job's name; this provides functionality
analogous to the % job identifier.
histchars
The two or three characters which control history
expansion and tokenization (see HISTORY EXPANSION
below). The first character is the history expansion
character, the character which signals the start of a
history expansion, normally `!'. The second character
is the quick substitution character, which is used as
shorthand for re-running the previous command entered,
substituting one string for another in the command.
The default is `^'. The optional third character is
the character which indicates that the remainder of the
line is a comment when found as the first character of
a word, normally `#'. The history comment character
causes history substitution to be skipped for the
remaining words on the line. It does not necessarily
cause the shell parser to treat the rest of the line as
a comment.
Arrays
Bash provides one-dimensional array variables. Any variable
may be used as an array; the declare builtin will explicitly
declare an array. There is no maximum limit on the size of
an array, nor any requirement that members be indexed or
assigned contiguously. Arrays are indexed using integers
and are zero-based.
An array is created automatically if any variable is
assigned to using the syntax name[subscript]=value. The
subscript is treated as an arithmetic expression that must
evaluate to a number greater than or equal to zero. To
explicitly declare an array, use declare -a name (see SHELL
BUILTIN COMMANDS below). declare -a name[subscript] is also
accepted; the subscript is ignored. Attributes may be
specified for an array variable using the declare and
readonly builtins. Each attribute applies to all members of
an array.
Arrays are assigned to using compound assignments of the
form name=(value1 ... valuen), where each value is of the
form [subscript]=string. Only string is required. If the
optional brackets and subscript are supplied, that index is
assigned to; otherwise the index of the element assigned is
the last index assigned to by the statement plus one.
Indexing starts at zero. This syntax is also accepted by
the declare builtin. Individual array elements may be
assigned to using the name[subscript]=value syntax
GNU Bash-3.0 Last change: 2004 June 26 24
User Commands BASH(1)
introduced above.
Any element of an array may be referenced using
${name[subscript]}. The braces are required to avoid con-
flicts with pathname expansion. If subscript is @ or *, the
word expands to all members of name. These subscripts
differ only when the word appears within double quotes. If
the word is double-quoted, ${name[*]} expands to a single
word with the value of each array member separated by the
first character of the IFS special 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 @ (see Special Parameters above). ${#name[subscript]}
expands to the length of ${name[subscript]}. If subscript
is * or @, the expansion is the number of elements in the
array. Referencing an array variable without a subscript is
equivalent to referencing element zero.
The unset builtin is used to destroy arrays. unset
name[subscript] destroys the array element at index sub-
script. unset name, where name is an array, or unset
name[subscript], where subscript is * or @, removes the
entire array.
The declare, local, and readonly builtins each accept a -a
option to specify an array. The read builtin accepts a -a
option to assign a list of words read from the standard
input to an array. The set and declare builtins display
array values in a way that allows them to be reused as
assignments.
EXPANSION
Expansion is performed on the command line after it has been
split into words. There are seven kinds of expansion per-
formed: brace expansion, tilde expansion, parameter and
variable expansion, command substitution, arithmetic expan-
sion, word splitting, and pathname expansion.
The order of expansions is: brace expansion, tilde expan-
sion, parameter, variable and arithmetic expansion and com-
mand substitution (done in a left-to-right fashion), word
splitting, and pathname expansion.
On systems that can support it, there is an additional
expansion available: process substitution.
Only brace expansion, word splitting, and pathname expansion
can change the number of words of the expansion; other
expansions expand a single word to a single word. The only
exceptions to this are the expansions of "$@" and
"${name[@]}" as explained above (see PARAMETERS).
GNU Bash-3.0 Last change: 2004 June 26 25
User Commands BASH(1)
Brace Expansion
Brace expansion is a mechanism by which arbitrary strings
may be generated. This mechanism is similar to pathname
expansion, but the filenames generated need not exist. Pat-
terns to be brace expanded take the form of an optional
preamble, followed by either a series of comma-separated
strings or a sequence expression between a pair of braces,
followed by an optional postscript. The preamble is pre-
fixed to each string contained within the braces, and the
postscript is then appended to each resulting string,
expanding left to right.
Brace expansions may be nested. The results of each
expanded string are not sorted; left to right order is
preserved. For example, a{d,c,b}e expands into `ade ace
abe'.
A sequence expression takes the form {x..y}, where x and y
are either integers or single characters. When integers are
supplied, the expression expands to each number between x
and y, inclusive. When characters are supplied, the expres-
sion expands to each character lexicographically between x
and y, inclusive. Note that both x and y must be of the
same type.
Brace expansion is performed before any other expansions,
and any characters special to other expansions are preserved
in the result. It is strictly textual. Bash does not apply
any syntactic interpretation to the context of the expansion
or the text between the braces.
A correctly-formed brace expansion must contain unquoted
opening and closing braces, and at least one unquoted comma
or a valid sequence expression. Any incorrectly formed
brace expansion is left unchanged. A { or , may be quoted
with a backslash to prevent its being considered part of a
brace expression. To avoid conflicts with parameter expan-
sion, the string ${ is not considered eligible for brace
expansion.
This construct is typically used as shorthand when the com-
mon prefix of the strings to be generated is longer than in
the above example:
mkdir /usr/local/src/bash/{old,new,dist,bugs}
or
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}
Brace expansion introduces a slight incompatibility with
historical versions of sh. sh does not treat opening or
closing braces specially when they appear as part of a word,
and preserves them in the output. Bash removes braces from
GNU Bash-3.0 Last change: 2004 June 26 26
User Commands BASH(1)
words as a consequence of brace expansion. For example, a
word entered to sh as file{1,2} appears identically in the
output. The same word is output as file1 file2 after expan-
sion by bash. If strict compatibility with sh is desired,
start bash with the +B option or disable brace expansion
with the +B option to the set command (see SHELL BUILTIN
COMMANDS below).
Tilde Expansion
If a word begins with an unquoted tilde character (`~'), all
of the characters preceding the first unquoted slash (or all
characters, if there is no unquoted slash) are considered a
tilde-prefix. If none of the characters in the tilde-prefix
are quoted, the characters in the tilde-prefix following the
tilde are treated as a possible login name. If this login
name is the null string, the tilde is replaced with the
value of the shell parameter HOME. If HOME is unset, the
home directory of the user executing the shell is substi-
tuted instead. Otherwise, the tilde-prefix is replaced with
the home directory associated with the specified login name.
If the tilde-prefix is a `~+', the value of the shell vari-
able PWD replaces the tilde-prefix. If the tilde-prefix is
a `~-', the value of the shell variable OLDPWD, if it is
set, is substituted. If the characters following the tilde
in the tilde-prefix consist of a number N, optionally pre-
fixed by a `+' or a `-', the tilde-prefix is replaced with
the corresponding element from the directory stack, as it
would be displayed by the dirs builtin invoked with the
tilde-prefix as an argument. If the characters following
the tilde in the tilde-prefix consist of a number without a
leading `+' or `-', `+' is assumed.
If the login name is invalid, or the tilde expansion fails,
the word is unchanged.
Each variable assignment is checked for unquoted tilde-
prefixes immediately following a : or =. In these cases,
tilde expansion is also performed. Consequently, one may
use file names with tildes in assignments to PATH, MAILPATH,
and CDPATH, and the shell assigns the expanded value.
Parameter Expansion
The `$' character introduces parameter expansion, command
substitution, or arithmetic expansion. The parameter name
or symbol to be expanded may be enclosed in braces, which
are optional but serve to protect the variable to be
expanded from characters immediately following it which
could be interpreted as part of the name.
When braces are used, the matching ending brace is the first
`}' not escaped by a backslash or within a quoted string,
GNU Bash-3.0 Last change: 2004 June 26 27
User Commands BASH(1)
and not within an embedded arithmetic expansion, command
substitution, or paramter expansion.
${parameter}
The value of parameter is substituted. The braces are
required when parameter is a positional parameter with
more than one digit, or when parameter is followed by a
character which is not to be interpreted as part of its
name.
If the first character of parameter is an exclamation point,
a level of variable indirection is introduced. Bash uses
the value of the variable formed from the rest of parameter
as the name of the variable; this variable is then expanded
and that value is used in the rest of the substitution,
rather than the value of parameter itself. This is known as
indirect expansion. The exceptions to this are the expan-
sions of ${!prefix*} and ${!name[@]} described below. The
exclamation point must immediately follow the left brace in
order to introduce indirection.
In each of the cases below, word is subject to tilde expan-
sion, parameter expansion, command substitution, and arith-
metic expansion. When not performing substring expansion,
bash tests for a parameter that is unset or null; omitting
the colon results in a test only for a parameter that is
unset.
${parameter:-word}
Use Default Values. If parameter is unset or null, the
expansion of word is substituted. Otherwise, the value
of parameter is substituted.
${parameter:=word}
Assign Default Values. If parameter is unset or null,
the expansion of word is assigned to parameter. The
value of parameter is then substituted. Positional
parameters and special parameters may not be assigned
to in this way.
${parameter:?word}
Display Error if Null or Unset. If parameter is null
or unset, the expansion of word (or a message to that
effect if word is not present) is written to the stan-
dard error and the shell, if it is not interactive,
exits. Otherwise, the value of parameter is substi-
tuted.
${parameter:+word}
Use Alternate Value. If parameter is null or unset,
nothing is substituted, otherwise the expansion of word
is substituted.
${parameter:offset}
${parameter:offset:length}
Substring Expansion. Expands to up to length
GNU Bash-3.0 Last change: 2004 June 26 28
User Commands BASH(1)
characters of parameter starting at the character
specified by offset. If length is omitted, expands to
the substring of parameter starting at the character
specified by offset. length and offset are arithmetic
expressions (see ARITHMETIC EVALUATION below). length
must evaluate to a number greater than or equal to
zero. If offset evaluates to a number less than zero,
the value is used as an offset from the end of the
value of parameter. If parameter is @, the result is
length positional parameters beginning at offset. If
parameter is an array name indexed by @ or *, the
result is the length members of the array beginning
with ${parameter[offset]}. Substring indexing is
zero-based unless the positional parameters are used,
in which case the indexing starts at 1.
${!prefix*}
${!prefix@}
Expands to the names of variables whose names begin
with prefix, separated by the first character of the
IFS special variable.
${!name[@]}
${!name[*]}
If name is an array variable, expands to the list of
array indices (keys) assigned in name. If name is not
an array, expands to 0 if name is set and null other-
wise. When @ is used and the expansion appears within
double quotes, each key expands to a separate word.
${#parameter}
The length in characters of the value of parameter is
substituted. If parameter is * or @, the value substi-
tuted is the number of positional parameters. If
parameter is an array name subscripted by * or @, the
value substituted is the number of elements in the
array.
${parameter#word}
${parameter##word}
The word is expanded to produce a pattern just as in
pathname expansion. If the pattern matches the begin-
ning of the value of parameter, then the result of the
expansion is the expanded value of parameter with the
shortest matching pattern (the ``#'' case) or the long-
est matching pattern (the ``##'' case) deleted. If
parameter is @ or *, the pattern removal operation is
applied to each positional parameter in turn, and the
expansion is the resultant list. If parameter is an
array variable subscripted with @ or *, the pattern
removal operation is applied to each member of the
array in turn, and the expansion is the resultant list.
GNU Bash-3.0 Last change: 2004 June 26 29
User Commands BASH(1)
${parameter%word}
${parameter%%word}
The word is expanded to produce a pattern just as in
pathname expansion. If the pattern matches a trailing
portion of the expanded value of parameter, then the
result of the expansion is the expanded value of param-
eter with the shortest matching pattern (the ``%''
case) or the longest matching pattern (the ``%%'' case)
deleted. If parameter is @ or *, the pattern removal
operation is applied to each positional parameter in
turn, and the expansion is the resultant list. If
parameter is an array variable subscripted with @ or *,
the pattern removal operation is applied to each member
of the array in turn, and the expansion is the resul-
tant list.
${parameter/pattern/string}
${parameter//pattern/string}
The pattern is expanded to produce a pattern just as in
pathname expansion. Parameter is expanded and the
longest match of pattern against its value is replaced
with string. In the first form, only the first match
is replaced. The second form causes all matches of
pattern to be replaced with string. If pattern begins
with #, it must match at the beginning of the expanded
value of parameter. If pattern begins with %, it must
match at the end of the expanded value of parameter.
If string is null, matches of pattern are deleted and
the / following pattern may be omitted. If parameter
is @ or *, the substitution operation is applied to
each positional parameter in turn, and the expansion is
the resultant list. If parameter is an array variable
subscripted with @ or *, the substitution operation is
applied to each member of the array in turn, and the
expansion is the resultant list.
Command Substitution
Command substitution allows the output of a command to
replace the command name. There are two forms:
$(command)
or
`command`
Bash performs the expansion by executing command and replac-
ing the command substitution with the standard output of the
command, with any trailing newlines deleted. Embedded new-
lines are not deleted, but they may be removed during word
splitting. The command substitution $(cat file) can be
replaced by the equivalent but faster $(< file).
GNU Bash-3.0 Last change: 2004 June 26 30
User Commands BASH(1)
When the old-style backquote form of substitution is used,
backslash retains its literal meaning except when followed
by $, `, or \. The first backquote not preceded by a
backslash terminates the command substitution. When using
the $(command) form, all characters between the parentheses
make up the command; none are treated specially.
Command substitutions may be nested. To nest when using the
backquoted form, escape the inner backquotes with
backslashes.
If the substitution appears within double quotes, word
splitting and pathname expansion are not performed on the
results.
Arithmetic Expansion
Arithmetic expansion allows the evaluation of an arithmetic
expression and the substitution of the result. The format
for arithmetic expansion is:
$((expression))
The expression is treated as if it were within double
quotes, but a double quote inside the parentheses is not
treated specially. All tokens in the expression undergo
parameter expansion, string expansion, command substitution,
and quote removal. Arithmetic expansions may be nested.
The evaluation is performed according to the rules listed
below under ARITHMETIC EVALUATION. If expression is
invalid, bash prints a message indicating failure and no
substitution occurs.
Process Substitution
Process substitution is supported on systems that support
named pipes (FIFOs) or the /dev/fd method of naming open
files. It takes the form of <(list) or >(list). The pro-
cess list is run with its input or output connected to a
FIFO or some file in /dev/fd. The name of this file is
passed as an argument to the current command as the result
of the expansion. If the >(list) form is used, writing to
the file will provide input for list. If the <(list) form
is used, the file passed as an argument should be read to
obtain the output of list.
When available, process substitution is performed simultane-
ously with parameter and variable expansion, command substi-
tution, and arithmetic expansion.
Word Splitting
The shell scans the results of parameter expansion, command
substitution, and arithmetic expansion that did not occur
GNU Bash-3.0 Last change: 2004 June 26 31
User Commands BASH(1)
within double quotes for word splitting.
The shell treats each character of IFS as a delimiter, and
splits the results of the other expansions into words on
these characters. If IFS is unset, or its value is exactly
<space><tab><newline>, the default, then any sequence of IFS
characters serves to delimit words. If IFS has a value
other than the default, then sequences of the whitespace
characters space and tab are ignored at the beginning and
end of the word, as long as the whitespace character is in
the value of IFS (an IFS whitespace character). Any charac-
ter in IFS that is not IFS whitespace, along with any adja-
cent IFS whitespace characters, delimits a field. A
sequence of IFS whitespace characters is also treated as a
delimiter. If the value of IFS is null, no word splitting
occurs.
Explicit null arguments ("" or '') are retained. Unquoted
implicit null arguments, resulting from the expansion of
parameters that have no values, are removed. If a parameter
with no value is expanded within double quotes, a null argu-
ment results and is retained.
Note that if no expansion occurs, no splitting is performed.
Pathname Expansion
After word splitting, unless the -f option has been set,
bash scans each word for the characters *, ?, and [. If one
of these characters appears, then the word is regarded as a
pattern, and replaced with an alphabetically sorted list of
file names matching the pattern. If no matching file names
are found, and the shell option nullglob is disabled, the
word is left unchanged. If the nullglob option is set, and
no matches are found, the word is removed. If the failglob
shell option is set, and no matches are found, an error mes-
sage is printed and the command is not executed. If the
shell option nocaseglob is enabled, the match is performed
without regard to the case of alphabetic characters. When a
pattern is used for pathname expansion, the character ``.''
at the start of a name or immediately following a slash must
be matched explicitly, unless the shell option dotglob is
set. When matching a pathname, the slash character must
always be matched explicitly. In other cases, the ``.''
character is not treated specially. See the description of
shopt below under SHELL BUILTIN COMMANDS for a description
of the nocaseglob, nullglob, failglob, and dotglob shell
options.
The GLOBIGNORE shell variable may be used to restrict the
set of file names matching a pattern. If GLOBIGNORE is set,
each matching file name that also matches one of the pat-
terns in GLOBIGNORE is removed from the list of matches.
GNU Bash-3.0 Last change: 2004 June 26 32
User Commands BASH(1)
The file names ``.'' and ``..'' are always ignored when GLO-
BIGNORE is set and not null. However, setting GLOBIGNORE to
a non-null value has the effect of enabling the dotglob
shell option, so all other file names beginning with a ``.''
will match. To get the old behavior of ignoring file names
beginning with a ``.'', make ``.*'' one of the patterns in
GLOBIGNORE. The dotglob option is disabled when GLOBIGNORE
is unset.
Pattern Matching
Any character that appears in a pattern, other than the spe-
cial pattern characters described below, matches itself.
The NUL character may not occur in a pattern. A backslash
escapes the following character; the escaping backslash is
discarded when matching. The special pattern characters
must be quoted if they are to be matched literally.
The special pattern characters have the following meanings:
* Matches any string, including the null string.
? Matches any single character.
[...]
Matches any one of the enclosed characters. A pair of
characters separated by a hyphen denotes a range
expression; any character that sorts between those two
characters, inclusive, using the current locale's col-
lating sequence and character set, is matched. If the
first character following the [ is a ! or a ^ then any
character not enclosed is matched. The sorting order
of characters in range expressions is determined by the
current locale and the value of the LC_COLLATE shell
variable, if set. A - may be matched by including it
as the first or last character in the set. A ] may be
matched by including it as the first character in the
set.
Within [ and ], character classes can be specified
using the syntax [:class:], where class is one of the
following classes defined in the POSIX.2 standard:
alnum alpha ascii blank cntrl digit graph lower print
punct space upper word xdigit
A character class matches any character belonging to
that class. The word character class matches letters,
digits, and the character _.
Within [ and ], an equivalence class can be specified
using the syntax [=c=], which matches all characters
with the same collation weight (as defined by the
current locale) as the character c.
Within [ and ], the syntax [.symbol.] matches the
GNU Bash-3.0 Last change: 2004 June 26 33
User Commands BASH(1)
collating symbol symbol.
If the extglob shell option is enabled using the shopt buil-
tin, several extended pattern matching operators are recog-
nized. In the following description, a pattern-list is a
list of one or more patterns separated by a |. Composite
patterns may be formed using one or more of the following
sub-patterns:
?(pattern-list)
Matches zero or one occurrence of the given pat-
terns
*(pattern-list)
Matches zero or more occurrences of the given pat-
terns
+(pattern-list)
Matches one or more occurrences of the given pat-
terns
@(pattern-list)
Matches exactly one of the given patterns
!(pattern-list)
Matches anything except one of the given patterns
Quote Removal
After the preceding expansions, all unquoted occurrences of
the characters \, ', and " that did not result from one of
the above expansions are removed.
REDIRECTION
Before a command is executed, its input and output may be
redirected using a special notation interpreted by the
shell. Redirection may also be used to open and close files
for the current shell execution environment. The following
redirection operators may precede or appear anywhere within
a simple command or may follow a command. Redirections are
processed in the order they appear, from left to right.
In the following descriptions, if the file descriptor number
is omitted, and the first character of the redirection
operator is <, the redirection refers to the standard input
(file descriptor 0). If the first character of the redirec-
tion operator is >, the redirection refers to the standard
output (file descriptor 1).
The word following the redirection operator in the following
descriptions, unless otherwise noted, is subjected to brace
expansion, tilde expansion, parameter expansion, command
substitution, arithmetic expansion, quote removal, pathname
expansion, and word splitting. If it expands to more than
one word, bash reports an error.
GNU Bash-3.0 Last change: 2004 June 26 34
User Commands BASH(1)
Note that the order of redirections is significant. For
example, the command
ls > dirlist 2>&1
directs both standard output and standard error to the file
dirlist, while the command
ls 2>&1 > dirlist
directs only the standard output to file dirlist, because
the standard error was duplicated as standard output before
the standard output was redirected to dirlist.
Bash handles several filenames specially when they are used
in redirections, as described in the following table:
/dev/fd/fd
If fd is a valid integer, file descriptor fd is
duplicated.
/dev/stdin
File descriptor 0 is duplicated.
/dev/stdout
File descriptor 1 is duplicated.
/dev/stderr
File descriptor 2 is duplicated.
/dev/tcp/host/port
If host is a valid hostname or Internet address,
and port is an integer port number or service
name, bash attempts to open a TCP connection to
the corresponding socket.
/dev/udp/host/port
If host is a valid hostname or Internet address,
and port is an integer port number or service
name, bash attempts to open a UDP connection to
the corresponding socket.
A failure to open or create a file causes the redirection to
fail.
Redirecting Input
Redirection of input causes the file whose name results from
the expansion of word to be opened for reading on file
descriptor n, or the standard input (file descriptor 0) if n
is not specified.
The general format for redirecting input is:
[n]<word
Redirecting Output
GNU Bash-3.0 Last change: 2004 June 26 35
User Commands BASH(1)
Redirection of output causes the file whose name results
from the expansion of word to be opened for writing on file
descriptor n, or the standard output (file descriptor 1) if
n is not specified. If the file does not exist it is
created; if it does exist it is truncated to zero size.
The general format for redirecting output is:
[n]>word
If the redirection operator is >, and the noclobber option
to the set builtin has been enabled, the redirection will
fail if the file whose name results from the expansion of
word exists and is a regular file. If the redirection
operator is >|, or the redirection operator is > and the
noclobber option to the set builtin command is not enabled,
the redirection is attempted even if the file named by word
exists.
Appending Redirected Output
Redirection of output in this fashion causes the file whose
name results from the expansion of word to be opened for
appending on file descriptor n, or the standard output (file
descriptor 1) if n is not specified. If the file does not
exist it is created.
The general format for appending output is:
[n]>>word
Redirecting Standard Output and Standard Error
Bash allows both the standard output (file descriptor 1) and
the standard error output (file descriptor 2) to be
redirected to the file whose name is the expansion of word
with this construct.
There are two formats for redirecting standard output and
standard error:
&>word
and
>&word
Of the two forms, the first is preferred. This is semanti-
cally equivalent to
>word 2>&1
Here Documents
This type of redirection instructs the shell to read input
from the current source until a line containing only word
(with no trailing blanks) is seen. All of the lines read up
GNU Bash-3.0 Last change: 2004 June 26 36
User Commands BASH(1)
to that point are then used as the standard input for a com-
mand.
The format of here-documents is:
<<[-]word
here-document
delimiter
No parameter expansion, command substitution, arithmetic
expansion, or pathname expansion is performed on word. If
any characters in word are quoted, the delimiter is the
result of quote removal on word, and the lines in the here-
document are not expanded. If word is unquoted, all lines
of the here-document are subjected to parameter expansion,
command substitution, and arithmetic expansion. In the
latter case, the character sequence \<newline> is ignored,
and \ must be used to quote the characters \, $, and `.
If the redirection operator is <<-, then all leading tab
characters are stripped from input lines and the line con-
taining delimiter. This allows here-documents within shell
scripts to be indented in a natural fashion.
Here Strings
A variant of here documents, the format is:
<<<word
The word is expanded and supplied to the command on its
standard input.
Duplicating File Descriptors
The redirection operator
[n]<&word
is used to duplicate input file descriptors. If word
expands to one or more digits, the file descriptor denoted
by n is made to be a copy of that file descriptor. If the
digits in word do not specify a file descriptor open for
input, a redirection error occurs. If word evaluates to -,
file descriptor n is closed. If n is not specified, the
standard input (file descriptor 0) is used.
The operator
[n]>&word
is used similarly to duplicate output file descriptors. If
n is not specified, the standard output (file descriptor 1)
is used. If the digits in word do not specify a file
GNU Bash-3.0 Last change: 2004 June 26 37
User Commands BASH(1)
descriptor open for output, a redirection error occurs. As
a special case, if n is omitted, and word does not expand to
one or more digits, the standard output and standard error
are redirected as described previously.
Moving File Descriptors
The redirection operator
[n]<&digit-
moves the file descriptor digit to file descriptor n, or the
standard input (file descriptor 0) if n is not specified.
digit is closed after being duplicated to n.
Similarly, the redirection operator
[n]>&digit-
moves the file descriptor digit to file descriptor n, or the
standard output (file descriptor 1) if n is not specified.
Opening File Descriptors for Reading and Writing
The redirection operator
[n]<>word
causes the file whose name is the expansion of word to be
opened for both reading and writing on file descriptor n, or
on file descriptor 0 if n is not specified. If the file
does not exist, it is created.
ALIASES
Aliases allow a string to be substituted for a word when it
is used as the first word of a simple command. The shell
maintains a list of aliases that may be set and unset with
the alias and unalias builtin commands (see SHELL BUILTIN
COMMANDS below). The first word of each simple command, if
unquoted, is checked to see if it has an alias. If so, that
word is replaced by the text of the alias. The characters
/, $, `, and = and any of the shell metacharacters or quot-
ing characters listed above may not appear in an alias name.
The replacement text may contain any valid shell input,
including shell metacharacters. The first word of the
replacement text is tested for aliases, but a word that is
identical to an alias being expanded is not expanded a
second time. This means that one may alias ls to ls -F, for
instance, and bash does not try to recursively expand the
replacement text. If the last character of the alias value
is a blank, then the next command word following the alias
is also checked for alias expansion.
GNU Bash-3.0 Last change: 2004 June 26 38
User Commands BASH(1)
Aliases are created and listed with the alias command, and
removed with the unalias command.
There is no mechanism for using arguments in the replacement
text. If arguments are needed, a shell function should be
used (see FUNCTIONS below).
Aliases are not expanded when the shell is not interactive,
unless the expand_aliases shell option is set using shopt
(see the description of shopt under SHELL BUILTIN COMMANDS
below).
The rules concerning the definition and use of aliases are
somewhat confusing. Bash always reads at least one complete
line of input before executing any of the commands on that
line. Aliases are expanded when a command is read, not when
it is executed. Therefore, an alias definition appearing on
the same line as another command does not take effect until
the next line of input is read. The commands following the
alias definition on that line are not affected by the new
alias. This behavior is also an issue when functions are
executed. Aliases are expanded when a function definition
is read, not when the function is executed, because a func-
tion definition is itself a compound command. As a conse-
quence, aliases defined in a function are not available
until after that function is executed. To be safe, always
put alias definitions on a separate line, and do not use
alias in compound commands.
For almost every purpose, aliases are superseded by shell
functions.
FUNCTIONS
A shell function, defined as described above under SHELL
GRAMMAR, stores a series of commands for later execution.
When the name of a shell function is used as a simple com-
mand name, the list of commands associated with that func-
tion name is executed. Functions are executed in the con-
text of the current shell; no new process is created to
interpret them (contrast this with the execution of a shell
script). When a function is executed, the arguments to the
function become the positional parameters during its execu-
tion. The special parameter # is updated to reflect the
change. Special parameter 0 is unchanged. The first ele-
ment of the FUNCNAME variable is set to the name of the
function while the function is executing. All other aspects
of the shell execution environment are identical between a
function and its caller with the exception that the DEBUG
trap (see the description of the trap builtin under SHELL
BUILTIN COMMANDS below) is not inherited unless the function
has been given the trace attribute (see the description of
the declare builtin below) or the -o functrace shell option
GNU Bash-3.0 Last change: 2004 June 26 39
User Commands BASH(1)
has been enabled with the set builtin (in which case all
functions inherit the DEBUG trap).
Variables local to the function may be declared with the
local builtin command. Ordinarily, variables and their
values are shared between the function and its caller.
If the builtin command return is executed in a function, the
function completes and execution resumes with the next com-
mand after the function call. Any command associated with
the RETURN trap is executed before execution resumes. When
a function completes, the values of the positional parame-
ters and the special parameter # are restored to the values
they had prior to the function's execution.
Function names and definitions may be listed with the -f
option to the declare or typeset builtin commands. The -F
option to declare or typeset will list the function names
only (and optionally the source file and line number, if the
extdebug shell option is enabled). Functions may be
exported so that subshells automatically have them defined
with the -f option to the export builtin. Note that shell
functions and variables with the same name may result in
multiple identically-named entries in the environment passed
to the shell's children. Care should be taken in cases
where this may cause a problem.
Functions may be recursive. No limit is imposed on the
number of recursive calls.
ARITHMETIC EVALUATION
The shell allows arithmetic expressions to be evaluated,
under certain circumstances (see the let and declare builtin
commands and Arithmetic Expansi |
Man Pages 