Bash

Bash AliasingBash ArithmeticBash ArraysBash Associative arraysBash Avoiding date using printfBash Brace ExpansionBash Case statementBash CGI ScriptsBash Chain of commands and operationsBash Change shellBash co-processesBash Color script output (cross-platform)Bash Conditional ExpressionsBash Control StructuresBash Copying (cp)Bash Creating directoriesBash Customizing PS1Bash Cut CommandBash DebuggingBash Decoding URLBash Design PatternsBash File execution sequenceBash File Transfer using scpBash FindBash FunctionsBash getopts : smart positional-parameter parsingBash global and local variablesBash GrepBash Handling the system promptBash Here documents and here stringsBash history substitutionsBash Internal variablesBash IntroductionBash Job ControlBash Jobs and ProcessesBash Jobs at specific timesBash Keyboard shortcutsBash Listing FilesBash Managing PATH environment variableBash MathBash NamespaceBash Navigating directoriesBash on Windows 10Bash ParallelBash Parameter ExpansionBash Pattern matching and regular expressionsBash PipelinesBash PitfallsBash Process substitutionBash Programmable completionBash QuotingBash Read a file (data stream, variable) line-by-line (and/or field-by-field)Bash RedirectionBash ScopingBash Script shebangBash Scripting with ParametersBash Select keywordBash Sleep utilityBash SourcingBash Splitting FilesBash straceBash the cut commandBash true, false and : commandsBash Type of ShellsBash Typing variablesBash Using catBash Using sortBash Using trap to react to signals and system eventsBash when to use evalBash Word splittingNetworking with Bash



Bash Control Structures

From WikiOD

Syntax[edit | edit source]

  • [ "$1" = "$2" ] #A "[" bracket is actually a command. Because of this it requires a space befor and after it.
  • test "$1" = "$2" #Test is a synonym for the "[" command

Parameters[edit | edit source]

Parameter to [ or test Details
File Operators Details
-e "$file" Returns true if the file exists.
-d "$file" Returns true if the file exists and is a directory
-f "$file" Returns true if the file exists and is a regular file
-h "$file" Returns true if the file exists and is a symbolic link
String Comparators Details
-z "$str" True if length of string is zero
-n "$str True if length of string is non-zero
"$str" = "$str2" True if string $str is equal to string $str2. Not best for integers. It may work but will be inconsitent
"$str" != "$str2" True if the strings are not equal
Integer Comparators       Details
"$int1" -eq "$int2" True if the integers are equal
"$int1" -ne "$int2" True if the integers are not equals
"$int1" -gt "$int2" True if int1 is greater than int 2
"$int1" -ge "$int2" True if int1 is greater than or equal to int2
"$int1" -lt "$int2" True if int1 is less than int 2
"$int1" -le "$int2" True if int1 is less than or equal to int2

Remarks[edit | edit source]

There are many comparator parameters available in bash. Not all are yet listed here.

If statement[edit | edit source]

if [[ $1 -eq 1 ]]; then
    echo "1 was passed in the first parameter"
elif [[ $1 -gt 2 ]]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

The closing fi is necessary, but the elif and/or the else clauses can be omitted.

The semicolons before then are standard syntax for combining two commands on a single line; they can be omitted only if then is moved to the next line.

It's important to understand that the brackets [[ are not part of the syntax, but are treated as a command; it is the exit code from this command that is being tested. Therefore, you must always include spaces around the brackets.

This also means that the result of any command can be tested. If the exit code from the command is a zero, the statement is considered true.

if grep "foo" bar.txt; then
    echo "foo was found"
else
    echo "foo was not found"
fi

Mathematical expressions, when placed inside double parentheses, also return 0 or 1 in the same way, and can also be tested:

if (( $1 + 5 > 91 )); then
    echo "$1 is greater than 86"
fi

You may also come across if statements with single brackets. These are defined in the POSIX standard and are guaranteed to work in all POSIX-compliant shells including Bash. The syntax is very similar to that in Bash:

if [ "$1" -eq 1 ]; then
    echo "1 was passed in the first parameter"
elif [ "$1" -gt 2 ]; then
    echo "2 was not passed in the first parameter"
else
    echo "The first parameter was not 1 and is not more than 2."
fi

Looping over an array[edit | edit source]

for loop:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
done

Or

for ((i=0;i<${#arr[@]};i++));do
    echo "${arr[$i]}" 
done

while loop:

i=0
while [ $i -lt ${#arr[@]} ];do
    echo "${arr[$i]}"
    i=$(expr $i + 1)
done

Or

i=0
while (( $i < ${#arr[@]} ));do
    echo "${arr[$i]}"
    ((i++))
done

Using For Loop to List Iterate Over Numbers[edit | edit source]

#! /bin/bash

for i in {1..10}; do # {1..10} expands to "1 2 3 4 5 6 7 8 9 10"
    echo $i
done

This outputs the following:

1
2
3
4
5
6
7
8
8
10

Conditional execution of command lists[edit | edit source]

How to use conditional execution of command lists[edit | edit source]

Any builtin command, expression, or function, as well as any external command or script can be executed conditionally using the &&(and) and ||(or) operators.

For example, this will only print the current directory if the cd command was successful.

cd my_directory && pwd

Likewise, this will exit if the cd command fails, preventing catastrophe:

cd my_directory || exit
rm -rf *

When combining multiple statements in this manner, it's important to remember that (unlike many C-style languages) these operators have no precedence and are left-associative.

Thus, this statement will work as expected...

cd my_directory && pwd || echo "No such directory"
  • If the cd succeeds, the && pwd executes and the current working directory name is printed. Unless pwd fails (a rarity) the || echo ... will not be executed.
  • If the cd fails, the && pwd will be skipped and the || echo ... will run.

But this will not (if you're thinking if...then...else)...

cd my_directory && ls || echo "No such directory"
  • If the cd fails, the && ls is skipped and the || echo ... is executed.
  • If the cd succeeds, the && ls is executed.
  • If the ls succeeds, the || echo ... is ignored. (so far so good)

BUT... if the ls fails, the || echo ... will also be executed.

It is the ls, not the cd, that is the previous command.

Why use conditional execution of command lists[edit | edit source]

Conditional execution is a hair faster than if...then but its main advantage is allowing functions and scripts to exit early, or "short circuit".

Unlike many languages like C where memory is explicitly allocated for structs and variables and such (and thus must be deallocated), bash handles this under the covers. In most cases, we don't have to clean up anything before leaving the function. A return statement will deallocate everything local to the function and pickup execution at the return address on the stack.

Returning from functions or exiting scripts as soon as possible can thus significantly improve performance and reduce system load by avoiding the unnecessary execution of code. For example...

my_function () {

    ### ALWAYS CHECK THE RETURN CODE

    # one argument required. "" evaluates to false(1)
    [[ "$1" ]]             || return 1

    # work with the argument. exit on failure
    do_something_with "$1" || return 1
    do_something_else      || return 1

    # Success! no failures detected, or we wouldn't be here
    return 0
}

Loop break[edit | edit source]

Break multiple loop:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break 2
    done
done

Output:

a
a

Break single loop:

arr=(a b c d e f)
for i in "${arr[@]}";do
    echo "$i"
    for j in "${arr[@]}";do
        echo "$j"
        break
    done
done

Output:

a
a
b
a
c
a
d
a
e
a
f
a

For Loop with C-style syntax[edit | edit source]

The basic format of C-style for loop is:

for (( variable assignment; condition; iteration process ))

Notes:

  • The assignment of the variable inside C-style for loop can contain spaces unlike the usual assignment
  • Variables inside C-style for loop aren't preceded with $.

Example:

for (( i = 0; i < 10; i++ ))
do
    echo "The iteration number is $i"
done

Also we can process multiple variables inside C-style for loop:

for (( i = 0, j = 0; i < 10; i++, j = i * i ))
do
    echo "The square of $i is equal to $j"
done

continue and break[edit | edit source]

Example for continue

for i in [series]
do
    command 1
    command 2
    if (condition) # Condition to jump over command 3
            continue # skip to the next value in "series"
    fi
    command 3
done

Example for break

for i in [series]
do
    command 4
    if (condition) # Condition to break the loop
    then
            command 5 # Command if the loop needs to be broken
            break
    fi
    command 6 # Command to run if the "condition" is never true 
done

While Loop[edit | edit source]

#! /bin/bash

i=0

while [ $i -lt 5 ] #While i is less than 5
do
    echo "i is currently $i"
    i=$[$i+1] #Not the lack of spaces around the brackets. This makes it a not a test expression
done #ends the loop

Watch that there are spaces around the brackets during the test (after the while statement). These spaces are necessary.

This loop outputs:

i is currently 0
i is currently 1
i is currently 2
i is currently 3
i is currently 4

Switch statement with case[edit | edit source]

With the case statement you can match values against one variable.

The argument passed to case is expanded and try to match against each patterns.

If a match is found, the commands upto ;; are executed.

case "$BASH_VERSION" in
 [34]*)
    echo {1..4}
    ;;  
  *)
    seq -s" " 1 4
esac

Pattern are not regular expressions but shell pattern matching (aka globs).

For Loop without a list-of-words parameter[edit | edit source]

for arg; do
    echo arg=$arg
done

A for loop without a list of words parameter will iterate over the positional parameters instead. In other words, the above example is equivalent to this code:

for arg in "$@"; do
    echo arg=$arg
done

In other words, if you catch yourself writing for i in "$@"; do ...; done, just drop the in part, and write simply for i; do ...; done.

Until Loop[edit | edit source]

Until loop executes until condition is true

i=5
until [[ i -eq 10 ]]; do #Checks if i=10
    echo "i=$i" #Print the value of i
    i=$((i+1)) #Increment i by 1
done

Output:

i=5
i=6
i=7
i=8
i=9

When i reaches 10 the condition in until loop becomes true and the loop ends.

For Loop[edit | edit source]

#! /bin/bash

for i in 1 "test" 3; do #Each space separated statement is assigned to i
    echo $i
done

Other commands can generate statements to loop over. See "Using For Loop to Iterate Over Numbers" example.

This outputs:

1
test
3

Credit:Stack_Overflow_Documentation