Bash is an sh-compatible command language interpreter that
executes commands read from the standard input or from a file.
Bashalso 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
interprets 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
interactive .
-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 executed.
[-+]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 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 gettextpo (portable object) file format.
--dump-strings
Equivalent to -D.
--help
Display a usage message on standard output and exit successfully.
--init-filefile
--rcfilefile
Execute commands from
file instead of the system wide initialization file
/etc/bash.bashrc and the standard personal 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
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 system wide initialization file
/etc/bash.bashrc and the personal initialization file
~/.bashrc if the shell is interactive.
This option is on by default if the shell is invoked as
sh .
--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 commands.
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 arguments
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
EXPANSION 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 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 /etc/bash.bashrc and ~/.bashrc,
if these files exist.
This may be inhibited by using the
--norc option.
The --rcfilefile option will force
bash to read and execute commands from file instead of
/etc/bash.bashrc and ~/.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 executed:
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
~/.profile , 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 command 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 /etc/bash.bashrc and ~/.bashrc,
if these files exist and are readable.
It will not 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 generally 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 effective 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 command:
! 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 assignments
followed by blank-separated words and redirections, and
terminated by a control operator. The first word
specifies the command to be executed, and is passed as argument zero.
The remaining words are passed as arguments to the invoked command.
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 performed 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 terminated 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 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 environment.
list must be terminated with a newline or semicolon.
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 [[ and ]]; tilde expansion, parameter and
variable expansion, arithmetic expansion, command substitution, process
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.
Substrings 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 regular 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 operators, listed
in decreasing order of precedence:
( expression )
Returns the value of expression.
This may be used to override the normal precedence of operators.
! expression
True if
expression is false.
expression1&&expression2
True if both
expression1 and
expression2 are true.
expression1||expression2
True if either
expression1 or
expression2 is true.
The && and
||
operators do not evaluate expression2 if the value of
expression1 is sufficient to determine the return value of
the entire conditional expression.
forname [ inword ] ; dolist ; done
The list of words following in is expanded, generating a list
of items.
The variable name is set to each element of this list
in turn, and list is executed each time.
If the inword is omitted, the for command executes
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 )) ; dolist ; 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
executed 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.
selectname [ inword ] ; dolist ; 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 inword 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 completes. 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.
casewordin [ [(] pattern [ |pattern ] A case command first expands word, and tries to match
it against each pattern in turn, using the same matching 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.
The
if list is executed. If its exit status is zero, the
thenlist is executed. Otherwise, each eliflist is executed in turn, and if its exit status is zero,
the corresponding thenlist is executed and the
command completes. Otherwise, the elselist is
executed, if present. The exit status is the exit status of the
last command executed, or zero if no condition tested true.
whilelist; dolist; done
untillist; dolist; done
The while command continuously executes the dolist 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 dolist 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 follows:
[ 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 command 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 executed 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 interactive shells.
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 follows,
with the exception of <newline>. If a \<newline> pair
appears, and the backslash is not itself quoted, the \<newline>
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 exception 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 following
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 character.
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
\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 hexadecimal 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 builtin 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 expansion, and quote
removal (see
EXPANSION below). If the variable 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 splitting is not performed, with the exception
of "$@" as explained below under
"Special Parameters" . Pathname expansion is not performed.
Assignment statements may also appear as arguments to the
alias , declare , typeset , export , readonly , and
local builtin commands.
Positional Parameters
A
positional parameter is a parameter denoted by one or more
digits, other than the single digit 0. Positional parameters are
assigned from the shell's arguments when it is invoked,
and may be reassigned using the
set builtin command. Positional parameters may not be assigned to
with assignment statements. The positional parameters are
temporarily 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
EXPANSION below).
Special Parameters
The shell treats several parameters specially. These parameters 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 parameters 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 () subshell, 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 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 argument 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 parameters in each
frame of the current bash execution call stack. The number of
parameters to the current subroutine (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 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 Programmable 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 completion 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 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 Programmable 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 function 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
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 substitutes
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 meaningful.
If
LINENO is unset, it loses its special properties, 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 command.
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
contain 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 of random numbers may be initialized by assigning
a value to
RANDOM . If
RANDOM is unset, it loses its special properties, even if it is
subsequently reset.
REPLY
Set to the line of input read by the
read builtin command 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 subsequent
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 containing commands to
initialize the shell, as in
~/.bashrc . The value of
BASH_ENV is subjected to parameter expansion, 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 command.
A sample value is
".:~:/usr".
COLUMNS
Used by the select builtin command to determine the terminal width
when printing selection lists. Automatically 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 performing
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:~".
(Quoting is needed when assigning a value to this variable,
which contains tildes).
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 commands 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
HISTIGNORE . 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 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 characters, `&'
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 history (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
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
to obtain the list of possible hostname completions.
When
HOSTFILE 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 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
(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 determines the behavior of range
expressions, equivalence classes, and collating sequences within
pathname expansion and pattern matching.
LC_CTYPE
This variable determines the interpretation of characters and the
behavior of character classes within pathname 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. Automatically set upon receipt of a SIGWINCH.
MAIL
If this parameter is set to a file name and the
MAILPATH 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 primary 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!"'
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 commands (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
running, 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 environment 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 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 determines 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\nsyst%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 terminal.
In an interactive shell, the value is interpreted as the
number of seconds to wait for input after issuing 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
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.
command_not_found_handle
The name of a shell function to be called if a command cannot be
found. The return value of this function should be 0, if the command
is available after execution of the function, otherwise 127 (EX_NOTFOUND).
Enabled only in interactive, non POSIX mode shells. This is a Debian
extension.
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 introduced above.
Any element of an array may be referenced using
${name[subscript]}. The braces are required to avoid
conflicts 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. unsetname[subscript]
destroys the array element at index subscript.
unsetname, where name is an array, or
unsetname[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 performed:
"brace expansion" , "tilde expansion" , "parameter and variable expansion" , "command substitution" , "arithmetic expansion" , "word splitting" , and
"pathname expansion" .
The order of expansions is: brace expansion, tilde expansion,
parameter, variable and arithmetic expansion and
command 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 ). 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. Patterns 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 prefixed 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 expression 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 expansion, the string ${
is not considered eligible for brace expansion.
This construct is typically used as shorthand when the common
prefix of the strings to be generated is longer than in the
above example:
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 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 expansion 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
substituted 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 variable
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 prefixed
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, 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 expansions 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 expansion,
parameter expansion, command substitution, and arithmetic 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 standard error and the shell, if it
is not interactive, exits. Otherwise, the value of parameter is
substituted.
${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 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.
Arithmetic expressions starting with a - must be separated by whitespace
from the preceding : to be
distinguished from the Use Default Values expansion.
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
otherwise.
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 substituted 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 beginning 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
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 resultant list.
${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
parameter 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 resultant 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
replacing the command substitution with the standard output of the
command, with any trailing newlines deleted.
Embedded newlines 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).
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 old format $[expression] is deprecated and will
be removed in upcoming versions of bash.
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 process list is run with its input or output connected to a
FIFO or some file in /dev/fd. The name of this file is
passed as an argument to the current command as the result of the
expansion. 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
simultaneously with parameter and variable expansion,
command substitution,
and arithmetic expansion.
Word Splitting
The shell scans the results of
parameter expansion,
command substitution,
and
arithmetic expansion
that did not occur 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 character in
IFS that is not
IFS whitespace, along with any adjacent
IFS whitespace characters, delimits a field.
A sequence of
IFS whitespace characters is also treated as a delimiter.
If the value of
IFS is null, no word splitting occurs.
Explicit null arguments (<3>"" or <3>'') are retained.
Unquoted implicit null arguments, resulting from the expansion of
parameters that have no values, are removed.
If a parameter with no value is expanded within double quotes, a
null argument results and is retained.
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 message
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.
Note that when using range expressions like
[a-z] (see below), letters of the other case may be included,
depending on the setting of
LC_COLLATE. 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 patterns in
GLOBIGNORE is removed from the list of matches.
The file names
``.'' and
``..'' are always ignored when
GLOBIGNORE 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 special 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 collating 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 collating symbol
symbol.
If the extglob shell option is enabled using the shopt
builtin, several extended pattern matching operators are recognized.
In the following description, a pattern-list is a list of one
or more patterns separated by a |.
Composite patterns may be formed using one or more of the following
sub-patterns:
?(pattern-list)
Matches zero or one occurrence of the given patterns
*(pattern-list)
Matches zero or more occurrences of the given patterns
+(pattern-list)
Matches one or more occurrences of the given patterns
@(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 <3>" 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 redirection 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.
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.
