Bash
Kontrollstrukturen

Syntax

• ["$ 1" = "$ 2"] #A "[" Klammer ist eigentlich ein Befehl. Aus diesem Grund benötigt es einen Raum vor und nach ihm.
• test "$ 1" = "$ 2" #Test ist ein Synonym für den Befehl "["

Parameter

Bemerkungen

Wenn Aussage

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

Die schließende fi ist notwendig, aber die elif und / oder die else Klausel können weggelassen werden.

Die Semikolons , bevor then sind Standardsyntax für die Kombination von zwei Befehlen in einer einzelnen Zeile; Sie können nur weggelassen werden, wenn then in die nächste Zeile verschoben wird.

Es ist wichtig zu verstehen, dass die Klammern [[ nicht Teil der Syntax sind, sondern als Befehl behandelt werden. Es ist der Exit-Code dieses Befehls, der gerade getestet wird. Daher müssen Sie immer Leerzeichen um die Klammern einschließen.

Dies bedeutet auch, dass das Ergebnis eines Befehls getestet werden kann. Wenn der Beendigungscode des Befehls eine Null ist, wird die Anweisung als wahr betrachtet.

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

Wenn mathematische Ausdrücke in doppelten Klammern stehen, geben sie ebenfalls 0 oder 1 zurück und können auch getestet werden:

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

Sie können auch kommen über , if Aussagen mit einzelnen Klammern. Diese sind im POSIX-Standard definiert und funktionieren garantiert in allen POSIX-kompatiblen Schalen, einschließlich Bash. Die Syntax ist der in Bash sehr ähnlich:

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

While-Schleife

#! /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

Achten Sie während des Tests auf Leerzeichen um die Klammern (nach der while-Anweisung). Diese Räume sind notwendig.

Diese Schleife gibt aus:

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

Für Schleife

#! /bin/bash

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

Andere Befehle können Anweisungen erzeugen, die überlaufen werden. Siehe Beispiel "Verwenden von For-Schleife zum Durchlaufen von Zahlen".

Dies gibt aus:

1
test
3

Verwenden von For-Schleife zum Auflisten von Zahlen über Zahlen

#! /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

Dies gibt Folgendes aus:

1
2
3
4
5
6
7
8
8
10

Für Loop mit C-Syntax

Das grundlegende Format von C-Stil for Schleife ist:

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

Anmerkungen:

• Die Zuweisung der Variablen innerhalb des C-Stils for Schleife kann im Gegensatz zur üblichen Zuordnung Leerzeichen enthalten
• Variablen innerhalb des C-Stils for Schleife sind nicht $ vorangestellt.

Beispiel:

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

Wir können auch mehrere Variablen im C-Stil for Schleife verarbeiten:

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

Bis zur Schleife

Bis die Schleife ausgeführt wird, bis die Bedingung erfüllt ist

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

Ausgabe:

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

Wenn i Wert 10 erreicht, wird die Bedingung eingehalten, bis die Schleife wahr wird und die Schleife endet.

weiter und brechen

Beispiel für weiter

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

Beispiel für Pause

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

Durchlaufen eines Arrays

for Schleife:

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

Oder

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

while Schleife:

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

Oder

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

Schleife brechen

Mehrfachschleife unterbrechen:

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

Ausgabe:

a
a

Einzelne Schleife abbrechen:

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

Ausgabe:

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

Anweisung mit case wechseln

Mit der case Anweisung können Sie Werte mit einer Variablen abgleichen.

Das an case Argument wird erweitert und versucht, mit den einzelnen Mustern abzugleichen.

Wenn eine Übereinstimmung gefunden wird, werden die Befehle bis zu ;; ausgeführt werden.

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

Muster sind keine regulären Ausdrücke, sondern die Übereinstimmung von Schalenmustern (Globs).

Für Schleife ohne Parameter für die Wortliste

for arg; do
    echo arg=$arg
done

Eine for Schleife ohne eine Liste von Wörtern wird stattdessen über die Positionsparameter iterieren. Mit anderen Worten entspricht das obige Beispiel diesem Code:

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

Mit anderen Worten, wenn Sie sich verfangen, for i in "$@"; do ...; done schreiben for i in "$@"; do ...; done , fallen nur die in Teil, und schreiben Sie doch einfach for i; do ...; done

Bedingte Ausführung von Befehlslisten

So verwenden Sie die bedingte Ausführung von Befehlslisten

Alle eingebauten Befehle, Ausdrücke oder Funktionen sowie alle externen Befehle oder Skripts können mit den Anweisungen && (und) und || bedingt ausgeführt werden (oder) Betreiber.

Das aktuelle Verzeichnis wird beispielsweise nur gedruckt, wenn der Befehl cd erfolgreich war.

cd my_directory && pwd

Ebenso wird dies beendet, wenn der Befehl cd fehlschlägt, um eine Katastrophe zu verhindern:

cd my_directory || exit
rm -rf *

Wenn Sie mehrere Anweisungen auf diese Weise kombinieren, müssen Sie daran denken, dass diese Operatoren (im Gegensatz zu vielen Sprachen im C-Stil) keinen Vorrang haben und links assoziativ sind .

Somit funktioniert diese Aussage wie erwartet ...

cd my_directory && pwd || echo "No such directory"

• Wenn das cd erfolgreich ist, wird das && pwd ausgeführt und der aktuelle Name des Arbeitsverzeichnisses wird gedruckt. Wenn pwd nicht ausfällt (eine Rarität), wird das || echo ... wird nicht ausgeführt.
• Wenn die cd fehlschlägt, wird das && pwd übersprungen und das || echo ... wird laufen.

Aber das wird nicht (wenn Sie denken, if...then...else ) ...

cd my_directory && ls || echo "No such directory"

• Wenn die cd fehlschlägt, wird das && ls übersprungen und das || echo ... wird ausgeführt.
• Wenn die cd erfolgreich ist, wird das && ls ausgeführt.
  • Wenn das ls erfolgreich ist, wird das || echo ... wird ignoriert. (So ​​weit, ist es gut)
  • ABER ... wenn das ls ausfällt, das || echo ... wird auch ausgeführt.

    Es ist die ls , nicht die cd , das ist der vorherige Befehl .

Warum bedingte Ausführung von Befehlslisten verwenden?

Die bedingte Ausführung ist ein Haar schneller als if...then aber der Hauptvorteil besteht darin, Funktionen und Skripts frühzeitig zu beenden, oder "Kurzschluss".

Im Gegensatz zu vielen Sprachen wie C denen Speicher explizit für Strukturen und Variablen (und muss daher freigegeben werden) zugewiesen werden, behandelt bash dies unter den Deckungen. In den meisten Fällen müssen wir vor dem Verlassen der Funktion nichts aufräumen. Eine return Anweisung hebt alle lokalen Funktionen für die Funktion und die Abholausführung an der Rücksprungadresse im Stapel auf.

Durch das frühzeitige Zurückkehren von Funktionen oder das Beenden von Skripts kann die Leistung erheblich verbessert und die Systemlast reduziert werden, da unnötige Ausführung von Code vermieden wird. Zum Beispiel...

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
}