Willkommen zum vierten Teil der Shell-Scripting-Tutorial-Reihe von HowtoForge (Klicken Sie hier, um Teil 1, Teil 2 und Teil 3 des Tutorials zu lesen). In diesem Teil werden wir die verschiedenen Wiederholungskontrollstrukturen der Bash-Shell und die Verwendung jeder Struktur anhand einiger Beispiele behandeln. Fangen wir an.
Einführung
Die Wiederholungskontrollstruktur, auch Schleifenkontrollstruktur genannt, ist eine Art Kontrollstruktur in Programmiersprachen, die verwendet wird, um sich wiederholende oder rekursive Aufgaben zu vereinfachen. Die Schleifenanweisungen optimieren jeden Code, indem sie eine Möglichkeit bieten, Code zu minimieren, was die Fehlerbehebung erleichtert als unstrukturierter Code, der die gleiche Ausgabe liefert. Es gibt drei Arten von Schleifenanweisungen, die die Bash-Shell unterstützt - die for-, while- und until-Schleifen.
For-Schleifen
Die for-Schleife ist eine Schleifenanweisung, die das Schlüsselwort for verwendet, um eine sich wiederholende Anweisung zu deklarieren. Die Bash unterstützt verschiedene Syntaxen für die for-Schleife-Anweisung:
Syntax 1:For-in-Struktur
for <varName> in <list>
do
#### your statement here
done
Diese Syntax beginnt mit dem Schlüsselwort for, gefolgt von einem Variablennamen, dem Schlüsselwort in und der Liste möglicher Werte für die Variable. Jeder Wert in der Liste wird durch ein Leerzeichen getrennt und der Beginn der zu wiederholenden Codezeilen wird im do definiert und endet mit einem done Schlüsselwort.
Lassen Sie uns eine einfache for-Schleife-Anweisung erstellen, die es dem Benutzer ermöglicht, 5 Werte einzugeben und die Summe der Zahlen zu erhalten:
#!/bin/bash
result=0;
input=0;
for var in 1 2 3 4 5
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo "the result is " $result
In diesem Beispiel dient die Variable var als Zähler unserer Schleife. Sein Wert wird in der Zahlenliste nach dem Schlüsselwort in definiert, und die Shell ändert die Werte der Variablen var nach jeder Ausführung des Zyklus in der Schleifenanweisung. Da unsere Liste nur fünf Integer-Werte enthält, führt die Shell die Codes in unserer Schleifenanweisung nur fünfmal aus.
Syntax 2:For looping-Anweisung mit String-Listenwerten
Sie können auch eine Variable deklarieren, die für die Liste der Elemente für Ihren Zähler gilt. Betrachten Sie beispielsweise den folgenden Code:
#!/bin/bash
list="var1 var2 var3 var4"
var=""
mkdir sample
cd sample
echo creating the "directories...."
for var in $list
do
mkdir $var
done
Die Zeile list="var1 var2 var3 var4" definiert die Werte der Listenvariable. Diese wurde dann in der Zeile für var in $list var zugewiesen und schließlich werden die Verzeichnisse dann in der Zeile mkdir $var angelegt.
Syntax 3:For-Schleife-Anweisung mit Liste als Datei
Sie können auch eine Liste aus einer vorhandenen Datei abrufen, die in einer Schleifenanweisung verwendet werden soll, anstatt sie mit dem cat-Befehl in Ihrem Code zu deklarieren. Öffnen Sie beispielsweise Ihren bevorzugten Texteditor und listen Sie mindestens fünf Verzeichnisnamen auf.
Öffnen Sie als nächstes eine neue Registerkarte im selben Texteditor und erstellen Sie ein neues Skript. Dieses Skript sollte in demselben Verzeichnis gespeichert werden, in dem die Liste der zuvor erstellten Verzeichnisse gespeichert ist.
#!/bin/bash
dirList=$(cat list)
echo "creating directories...."
for var in $dirList
do
mkdir $var
done
Dieses Beispiel ist praktisch, wenn Sie Hunderte von Verzeichnissen auf Ihrem Linux-Computer erstellen müssen, finden Sie nicht?
Syntax 4:C-ähnliche Syntax
for((initialization; boolean_test; increment/decrement))
do
#### your code goes here
done
Die vielleicht bekannteste Struktur der for-Schleife, die die Shell unterstützt, ist die C-ähnliche Struktur. Die Schleife beginnt mit der Initialisierung der Zählervariablen und anschließend wertet die Shell den nach der Initialisierung deklarierten booleschen Ausdruck aus. Wenn das Ergebnis des booleschen Ausdrucks wahr ist, führt die Shell den Satz von Anweisungen innerhalb der do-Klausel aus, andernfalls beendet sie die Schleifenanweisung und fährt mit der Zeile nach dem Schlüsselwort done fort. Die Shell fährt mit der nächsten Iteration durch die nach dem booleschen Test deklarierte Inkrement- oder Dekrementanweisung fort. Lassen Sie uns als Beispiel unser erstes Beispiel mit dieser Struktur rekonstruieren.
#!/bin/bash
result=0
input=0
for((var=1;var<=5;var++))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo $result
While-Looping-Anweisung
Die While-Anweisung ist eine Art sich wiederholender Struktur in Bash, die das Schlüsselwort while verwendet. Im Gegensatz zur C-Typ-Syntax der for-Schleifenstruktur trennt die sich wiederholende While-Kontrollstruktur die Initialisierung, den booleschen Test und die Inkrement/Dekrement-Anweisung.
Syntax 1:While-Struktur mit auf arithmetischen Symbolen basierenden bedingten Anweisungen
<initialization>
while(condition)
do
###your code goes here
<increment/decrement>
done
Um while von den anderen Schleifenanweisungen unterscheiden zu können, konstruieren wir unser erstes Beispiel für die while-Anweisung.
#!/bin/bash
result=0
input=0
var=1
while((var <= 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
In unserem Beispiel beginnt die while-Anweisung mit einer Initialisierung unserer Zählervariablen var. Als nächstes wird der boolesche Test nach dem Schlüsselwort while deklariert, und die zu wiederholenden Anweisungen werden innerhalb der do- und done-Anweisungen deklariert. In while-Anweisungen startet und führt der Interpreter die Wiederholung von Codes nur dann aus, wenn das boolesche Testergebnis wahr ist. Andererseits beendet die Schleifenanweisung will die Iteration von Codes nur, wenn der boolesche Ausdruck falsch ist.
Syntax 2:While-Looping-Anweisung mit mnemonikbasierter bedingter Anweisung
<initialization>
while [ <condition> ]
do
####your code goes here
<increment/decrement>
done
Sie können auch mnemonische bedingte Anweisungen innerhalb einer While-Schleifenanweisung deklarieren. Bei der Deklaration wird anstelle der runden Klammer eine eckige Klammer verwendet. (Sehen Sie sich hier die mnemonischen bedingten Anweisungen an.) Zum Beispiel:
#!/bin/bash
var=1;
while [ $var -le 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Syntax 3:While-Looping-Anweisung mit dateibasierter bedingter Anweisung
while read <variable_name>
do
####your code goes here
done <<path to the text file>
Genau wie bei der for-Schleife-Anweisung können Sie auch eine Textdatei öffnen und sie der while-Schleife-Anweisung zuordnen. Zum Beispiel:
#!/bin/bash
mkdir sample2
cd sample2
echo "creating directories..."
while read var
do
mkdir $var
done<list
In diesem Beispiel habe ich die Liste, die wir vor einiger Zeit erstellt haben, recycelt und ein neues Skript im selben Verzeichnis erstellt. Beachten Sie, dass Sie, wenn sich Ihre Textdatei in einem anderen Verzeichnis befindet, den genauen Pfad der Datei nach dem <-Symbol angeben müssen.
Until-Looping-Anweisung
Eine andere Art von Schleifenanweisung, die die Bash unterstützt, ist die until-Struktur. Die until-Anweisung führt jeden Befehl innerhalb der Schleife aus, bis der deklarierte boolesche Ausdruck falsch ist. Es ist das komplette Gegenteil der while-Anweisung.
Syntax 1:Until-Schleife mit arithmetischer symbolbasierter bedingter Anweisung
until ((<conditional_statement>))
do
####set of commands
done
Lassen Sie uns ein Beispiel haben:
result=0
input=0
var=1
until((var > 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Syntax 2:Until-Looping-Anweisung mit mnemonikbasierter bedingter Anweisung
<initialization>
until [ <condition> ]
do
####your code goes here
<increment/decrement>
done
Da die until-Anweisung genau das Gegenteil der while-Schleife ist, können Sie in der until-Struktur auch eine mnemonische bedingte Anweisung deklarieren. Um die zu beenden, müssen Sie jedoch eine entgegengesetzte bedingte Anweisung deklarieren - das heißt, die bedingte Anweisung als falsch auswerten.
!/bin/bash
result=0
input=0
var=1
until [ $var -gt 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Schlussfolgerung
Dieser Tutorial-Teil behandelt die drei Schleifenstrukturen, die die Bash unterstützt - die Schleifenanweisung for, while und until. Jede dieser Anweisungen hat eine andere Struktur, Verwendung und Vorteile. Die Bash unterstützt verschiedene Strukturen, bietet Programmierern mehr Auswahlmöglichkeiten und macht Shell-Scripting somit einfacher zu programmieren.