Bash Parameters and Variables
Internal
Parameters and Variables
Shell stores values internally using entities named parameters.
Parameters can be designated by a number (e.g. 1), a special character (e.g. *), or a name (e.g. blue). Parameters designated by a name are referred to as variables. The variables that have a special meaning to the shell (for example "IFS") are known as internal, keyword or built-in variables. Non-variable parameters can be further categorized in positional parameters, which are the shell's command line arguments, retrievable as $1, $2, etc. and special parameters, that are denoted by special characters.
Parameter and Variable Expansion - Accessing a Parameter's or Variable's Value
A dollar sign ($) that is NOT followed by an open parenthesis initiates parameter or variable expansion. The simplest case of expansion is retrieving the parameter or variable value: the associated value is retrieved by prefixing the parameter/variable's number, character or name with $ or enclosing it in ${...}. bash supports complex parameter expansion rules, documented here:
Positional Parameters $1, $2, ...
A positional parameter is a parameter denoted by one or more digits, other than the single digit 0 (the single digit 0 denotes the special parameter $0).
bash allows only nine parameters to be referenced directly (n = 1–9) as in:
$1
$1 is equivalent with ${1}.
When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces. For n values greater than 9, the command line arguments must be specified as ${n}:
${10}
Positional parameters are assigned from the shell’s arguments when it is invoked. They may not be assigned to with assignment statements, but they can be reassigned with set builtin command and they can be shifted left with the bash built-in command shift.
The positional parameters are temporarily replaced when a shell function is executed.
Iterating over Positional Paramenters
Solution 1
while [ -n "$1" ]; do ... shift done
Solution 2
Special Parameters
For a list of special parameters, see:
Variables
A variable is a shell parameter designated by a name, not a number or a special character. Variables can be user-created, or built-in.
Variable Assignment
Unlike positional parameters and special parameters, variable can be assigned values by using the "=" character, with no spaces before or after:
blue=10
Built-in Variables
The variables that have a special meaning to the shell (for example "IFS") are known as internal, keyword or built-in variables. For a list of built-in variables, see:
Undeclared Variable
An undeclared variable is equivalent with an empty string when referenced. There is no error when such a variable is referenced in a bash program:
echo ">${no_such_var}<"
><
Uninitialized Variable
An uninitialized variable is equivalent with an empty string when referenced. There is no error when such a variable is referenced in a bash program:
local some_var
echo ">${some_var}<"
><
Global Variable
Global variables are only maintained within the context of the current shell. Once the shell exits, the global variables are discarded.
The global variables declared in a shell are visible inside the functions executed within that shell and inside functions invoked from function invoked from the shell, recursively.
The value of a global variable is not available to sub-shells, unless the variable is exported, with the #export keyword.
export
export VAR=VALUE
Declaring a global variable to be exported causes the variable and its value to be copied in the environment of a sub-shell. The sub-shell gets a copy of the variable, not a reference. The sub-shell has no access to the parent process's environment whatsoever. Modifying the variable from the sub-shell does not reflect into the value of the global variable maintained by the invoking shell. When the shell sub-process terminates any changes made to its environment are lost. There is no way to modify directly the parent's environment.
Variables exported by Sub-Shells
If a sub-shell invoked from another shell exports a global variable, once the sub-shell exits, the exported variables are discarded, and the invoking shell does not sees them.
Local Variable
If a variable is declared inside a function, without any qualifier, it automatically becomes a global variable, and it is visible to the entire shell after the function execution, even after the function exits.
In order to prevent a variable declared inside of a function to become global, it must be declared as local: the local keyword designates a local variable. Local variables can only be declared inside a function.
Example:
local a=b
Local Variable Assignment and Failure
Do not do a local variable assignment from a function that may return non-zero and expect to use the return value to exit
Do not do something like this:
local a=$(do_something) || exit 1 # hoping to exit if 'do_something' returns a non-zero value
Even if do_something returns a non-zero error code, that is not detected and exit is not executed.
Do this instead:
local a; a=$(do_something) || exit
Listing Declared Variables
declare -p
A way of obtaining the value for a specific variable is:
local var_name="HISTSIZE"
declare -p | grep "declare .. ${var_name}" | sed -e 's/.*=//'
Booleans
Recommended usage pattern:
Declaration:
some_var=true
Usage:
${some_var} && echo "this will execute"
if ${some_var}; then
echo "this will execute"
fi
Do not use:
if [ ${some_var} ]; then ...
This will always evaluate to "true" regardless of the some_var value.