bash — standard shell

Basic selection

The basic conditional operator is the if statement:

if something ; then
	do_stuff
fi

Multiple selection

Multiple pronged selection can be done using else and elif:

if something ; then
	do_stuff
elif something_else ; then
	do_other_stuff
elif full_moon ; then
	howl
else
	turn_into_a_newt
fi

if some_stuff ; then
	# A statement is required here. a blank or a comment
	# isn't enough!
else
	einfo "Not some stuff"
fi

If you really don't want to restructure the block, you can use a single colon (:) on its own as a null statement.

if some_stuff ; then
	# Do nothing
	:
else
	einfo "Not some stuff"
fi

Selection tests

To do comparisons or file attribute tests, [[ ]] (preferred) or [ ] blocks are needed.

# is ${foo} zero length?
if [[ -z ${foo} ]] ; then
	die "Please set foo"
fi

# is ${foo} equal to "moo"?
if [[ ${foo} == "moo" ]] ; then
	einfo "Hello Larry"
fi

# does ${ROOT}/etc/deleteme exist?
if [[ -f ${ROOT}/etc/deleteme ]] ; then
	einfo "Please delete ${ROOT}/etc/deleteme manually!"
fi

Single versus double brackets in bash

POSIX compliance is not a concern for ebuilds, as their interpreter is guaranteed to be GNU Bash. POSIX style tests have different semantics and using the common forms of tests adheres to the principle of least surprise. Most developers will be used to Bash test semantics and behaviour and deviating from this in ebuilds may be confusing.

This is because [[ ]] is a bash syntax construct, whereas [ ] is a program which happens to be implemented as an internal — as such, cleaner syntax is possible with the former. For a simple illustration, consider:

bash$ [ -n ${foo} ] && [ -z ${foo} ] && echo "huh?"
huh?
bash$ [[ -n ${foo} ]] && [[ -z ${foo} ]] && echo "huh?"
bash$

String comparison in bash

The general form of a string comparison is string1 operator string2. The following are available:

String tests in bash

The general form of string tests is -operator "string". The following are available:

Integer comparison in bash

The general form of integer comparisons is int1 -operator int2. The following are available:

File tests in bash

The general form of a file test is -operator "filename". The following are available (lifted from man bash):

File comparison in bash

The general form of a file comparison is "file1" -operator "file2". The following are available:

Boolean algebra in bash

There are constructs available for boolean algebra ('and', 'or' and 'not'). These are used outside of the [[ ]] blocks. For operator precedence, use ( ).

Inside [ ] blocks, several -test style boolean operators are available. These should be avoided in favour of [[ ]] and the above operators.

bash string length

The ${#somevar} construct can be used to obtain the length of a string variable.

somevar="Hello World"
echo "${somevar} is ${#somevar} characters long"

bash variable default values

There are a number of ways of using a default value if a variable is unset or zero length. The ${var:-value} construct expands to the value of ${var} if it is set and not null, or value otherwise. The ${var-value} construct is similar, but checks only that the variable is set.

The ${var:=value} and ${var=value} forms will also assign value to var if var is unset (and also set, but null for the := form).

The ${var:?message} form will display message to stderr and then exit if var is unset or null. This should generally not be used within ebuilds as it does not use the die mechanism. There is a ${var?message} form too.

The ${var:+value} form expands to value if var is set and not null, or a blank string otherwise. There is a ${var+value} form.

bash substring extraction

The ${var:offset} and ${var:offset:length} constructs can be used to obtain a substring. Strings are zero-indexed. Both offset and length are arithmetic expressions.

The first form with a positive offset returns a substring starting with the character at offset and continuing to the end of a string. If the offset is negative, the offset is taken relative to the end of the string.

The second form returns the first length characters of the value of ${var} starting at offset. If offset is negative, the offset is taken from the end of the string. The length parameter must not be less than zero. Again, negative offset values must be given as an expression.

bash command substitution

The $(command) construct can be used to run a command and capture the output (stdout) as a string.

myconf="$(use_enable acl) $(use_enable nls) --with-tlib=ncurses"

bash string replacements

There are three basic string replacement forms available: ${var#pattern}, ${var%pattern} and ${var/pattern/replacement}. The first two are used for deleting content from the start and end of a string respectively. The third is used to replace a match with different content.

The ${var#pattern} form will return var with the shortest match of pattern at the start of the value of var deleted. If no match can be made, the value of var is given. To delete the longest match at the start, use ${var##pattern} instead.

The ${var%pattern} and ${var%%pattern} forms are similar, but delete the shortest and longest matches at the end of var respectively.

The ${var/pattern/replacement} construct expands to the value of var with the first match of pattern replaced with replacement. To replace all matches, ${var//pattern/replacement} can be used.

To match only if pattern occurs at the start of the value of var, the pattern should begin with a # character. To match only at the end, the pattern should begin with a %.

If replacement is null, matches are deleted and the / following pattern may be omitted.

The pattern may contain a number of special metacharacters for pattern matching.

Refer to the Bash Reference Manual for further details and caveats regarding these characters.

If the extglob shell option is enabled, a number of additional constructs are available. These can be extremely useful sometimes. In the following table, a pattern-list is a list of one or more patterns separated by |.

bash arithmetic expansion

The $(( expression )) construct can be used for integer arithmetic evaluation. expression is a C-like arithmetic expression. The following operators are supported (the table is in order of precedence, highest first):