Bash Parameter and Variable Expansion

From NovaOrdis Knowledge Base
Jump to: navigation, search

Internal

Overview

A dollar sign ($) that is NOT followed by an open parenthesis initiates parameter or variable expansion, which is a particular case of command line expansion. The simplest case of parameter expansion is retrieving the parameter value: the associated value is retrieved by prefixing the parameter's number, character or name with $ or enclosing it in ${...}.

Parameters and variables are not expanded if the string they are included in are enclosed within single quotes or if the leading dollar sign is escaped. Parameters and variables are expanded if the string they are included in is enclosed within double quotes.

a=10
echo "${a}"
echo '${a}'

produces

10
${a}

Difference between $ and ${...}

TODO

Expand to a Default Value

http://wiki.bash-hackers.org/syntax/pe#use_a_default_value
https://unix.stackexchange.com/questions/122845/using-a-b-for-variable-assignment-in-scripts/122878
${var:-alternative}

The :- form : if the variable 'var' referred in the expression was not defined, or it is the empty string, the expression expands the alternative.

${var-alternative}

The - form: if the colon is omitted, the expression is expanded to the alternative value only if the variable is not defined, not when it was empty.

Assign a Default Value

http://wiki.bash-hackers.org/syntax/pe#assign_a_default_value
 ${var:=word}
${var=word}

This expression works like expansion to a default value, but the word is not only expanded, but also assigned to the variable, if it was unset or null.

The first form := work if the variable is unset or an empty string, the second = only if the parameter was unset.

Use an Alternate Value

http://wiki.bash-hackers.org/syntax/pe#use_an_alternate_value
${var:+alternative}

This form expands to nothing if the parameter is unset or empty.

${var+alternative}

This form expands to nothing if the variable is unset, and to the alternative if the variable is empty.

Variable Expansion in an Arbitrary File

If an arbitrary text file contains environment variable declarations, they can be expanded with envsubst. No other shell command line expansions will be performed. More details:

envsubst

String Length ${#var}

The length of a variable's value:

${#var}

$!... Indirect Variables, Variable Indirection, Indirect Expansion

If the first character of parameter is an exclamation point (!), a level of variable indirection is introduced. Bash uses the value of the variable indicated by 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 immediately after the left brace in order to introduce indirection. Example:

# 'a' is the indirect variable, that contains the name of the actual variable, b:
a="b"
b="blah"
echo ${!a}

produces "blah".

Assignment to Indirect Variables

Values can be assigned to an indirect variable with the following syntactic pattern:

eval "${indirect_variable_name}=value"

or even:

eval "${indirect_variable_name}=\"value\""

As such,

a="b"
eval "${a}=blah"
echo ${b}

produces "blah".

It seems that under some circumstances it is possible to assign a value to an indirect variable simply using ${indirect_variable_name}=value syntax, but this seems to fail with bash 4 and 5:

a="b"
${a}="blah"
b=blah: command not found

In each of the cases below, word is subject to tilde expansion, parameter expansion, command substitution, and arithmetic expansion.

When not performing substring expansion, using the forms documented below, bash tests for a parameter that is unset or null. Omitting the colon results in a test only for a parameter that is unset.

Indirect Variable Access for Indexed Arrays

Bash Arrays - Indirect Variable Access for Indexed Arrays

Indirect Variable Access for Associative Arrays

Bash Arrays - Indirect Variable Access for Associative Arrays

Quoted String Expansion $'...'

This construct expands single or multiple escaped octal or hex values into ASCII or Unicode characters.

The following are equivalent:

$'\012' # Octal value
$'\x0a' # Hexadecimal value
$'\n'

Example:

echo "something"$'\047'"something else"$'\047'
The octal and hexadecimal values for ASCII characters are available here:
ASCII

Extract Substrings

Extract a Substring from a Certain Position

Specify the index of the first character of the substring. Indices are 0-based. The substring will extend the end of the original string.

There is no need to de-reference the variable that contains the index in ${s:i}, though ${s:${i}} will also work.

s="something"
i=4
result=${s:i}

produces "thing"

Extract a Substring of a Certain Length from a Certain Position

Specify the index of the first character of the substring and the length of the string to extract. Indices are 0-based.

There is no need to de-reference the variable that contains the index in ${s:i}, though ${s:${i}} will also work.

s="something"
i=5
len=2
result=${s:i:len}

produces "hi"

Last Character of a String

Negative indices count from the end of the string, so the last character is:

s="something"
result=${s: -1}

produces "g"


The space after the colon is required otherwise the expression will silently fail to evaluate and return the whole string.

Replace Substrings

All of the examples below use bash patterns. The pattern format is described in
bash Patterns

Replace Beginning

${var_name/#pattern/replacement}

Example:

s="something"
echo ${s/#s*e/other}

produces "otherthing".

Replace End

${var_name/%pattern/replacement}

Replace First Match

${var_name/pattern/replacement}

Replace All Matches

${var_name//pattern/replacement}

Application: determine whether a variable contains spaces.

Conversion of a comma-separated list to a space-separated list:

${var_name//,/ }

Delete Substrings

Delete from the Front of the String

Delete Shortest Matching Leading String

The following syntax deletes the shortest matching string from the front of the given string.

${var_name#pattern}

Example:

s="something"
echo ${s#s*e}

produces "thing".

Delete Longest Matching Leading String

${var_name##pattern}

Trimming leading spaces: trim.

Delete from the Back of the String

Delete Shortest Matching Trailing String

The following syntax deletes the shortest matching string from the back of the given string.

${var_name%pattern}

Example:

s="something"
echo ${s%t*g}

produces "some".

Delete Longest Matching Trailing String

${var_name%%pattern}

Trimming trailing spaces: trim.

To Uppercase

Other approaches: using tr.

First Character

${var_name^}

All Characters

${var_name^^}

To Lowercase

Other approaches: using tr.

First Character

${var_name,}

All Characters

${var_name,,}