Verschachtelt für Loop in Bash

Abdul Mateen 8 Oktober 2023
  1. Variationen der for-Schleife in Bash
  2. Verschachtelte for-Schleife in Bash
Verschachtelt für Loop in Bash

In diesem Tutorial werden wir verschachtelte Schleifen in Bash besprechen. Zuerst werden wir schnell die verschiedenen verfügbaren for-Schleifenformulierungen in Bash besprechen. Als nächstes besprechen wir die verschachtelte for-Schleife mit Beispielen.

Variationen der for-Schleife in Bash

Schauen wir uns zunächst die Syntax der for-Schleife in der Bash an:

for var in something
do
    command
done

In dieser Syntax ist der Variablenname die Wahl des Benutzers. Es gibt mehrere Optionen für etwas, auf die wir gleich eingehen werden.

Wir können eine beliebige Anzahl von Befehlen in den Körper for schreiben. In bash sind mehrere for-Schleifenvariationen verfügbar; wir werden unten schnell einige sehen.

for im Zahlenbereich

Wir können eine Liste von Zahlen mit einer for-Schleife spezifizieren und diese Zahlen eine nach der anderen durchlaufen, wie im folgenden Beispiel dargestellt:

for i in 1 3 8
do
    echo $i
done

Die Schleife iteriert über die angegebene Werteliste (z. B. 1 3 8). In diesem speziellen Beispiel lautet die Ausgabe:

1
3
8

for in der Werteliste

Wir können eine Liste von Werten definieren und wie folgt über die Liste iterieren:

x=(1 3 8)
for i in ${x[@]}
do
    echo $i
done

Das Ergebnis dieses Codes entspricht der Ausgabe des vorherigen Beispiels. In der Schleifenanweisung for steht {x[@]} für: für jedes Element der Liste x.

for im Bereich einer Sequenz

Wir können einen Wertebereich mit einer Startnummer angeben, gefolgt von einem Doppelpunkt (..), gefolgt von einer Endnummer. In ähnlicher Weise können wir ein weiteres Punktpaar gefolgt von einem Schritt setzen.

Schauen wir uns zum Beispiel die folgenden zwei Beispielschleifenformulierungen an:

for i in {1..3}
do
    echo $i
done
echo "----------------------"
for i in {1..3..2}
do
    echo $i
done

Die Ausgabe dieses Codes wird sein:

1
2
3
----------------------
1
3

für in Zeichenfolge mit Wörtern

Wir können eine durch Leerzeichen getrennte Liste von Wörtern in einer Zeichenfolge definieren und wie folgt über die Wörter in der Zeichenfolge iterieren:

names="Asim Babar Munir Ali"
for name in $names
do
    echo $name
done

Der Ausgabe dieses Codes werden wie folgt in separaten Zeilen Namen gegeben.

Asim
Babar
Munir
Ali

C-Style for-Ausdruck

Wir können in der for-Schleife einen Ausdruck ähnlich dem for in der C-Sprache angeben. Siehe das Beispiel:

for ((i=1;i<=5;i++))
do
    echo $i
done

Es wird die folgende Ausgabe erzeugt:

1
2
3
4
5

Verwendung der continue-Anweisung in der for-Schleife

Wir können einige Bedingungen in den Rumpf der for-Schleife schreiben, gefolgt von einer continue-Anweisung, um den nächsten Schleifenrumpf zu überspringen. Siehe das Beispiel:

for ((i=1;i<=5;i++))
do
    if [ $i == 3 ]
    then
        continue
    fi
    echo $i
done

Aufgrund der if-Bedingung überspringt die Schleife den echo-Befehl für den Wert 3; daher lautet die Ausgabe: 1 2 4 5.

Befehlszeilenargumente durchlaufen

Wir können unserem Bash-Skript Befehlszeilenargumente geben und eine for-Schleife über die durch Leerzeichen getrennten Argumente ausführen. Siehe das Beispiel:

for i in $@
do
    echo "Script arg is $i"
done

In der ersten Zeile stellt das Symbol $@ eine Liste von Argumenten dar, die durch Leerzeichen getrennt sind. Sehen Sie sich die Ausgabe für dieses Beispiel an:

bash myscript.sh 13 28
Script arg is 13
Script arg is 28

Schleife über die Ausgabe des Befehls

Wir können die for-Schleife über die Ausgabe eines Befehls laufen lassen. Siehe das Beispiel:

for f in $(ls)
do
  echo "**** $f *****"
done

Dieses Skript nimmt die Ausgabe des Befehls ls und iteriert über die Werte. Siehe Beispielausgabe:

**** first.c *****
**** second.c *****
**** third.c *****

Schleife über Variablensequenz

Wir können auch einige Eingaben basierend auf einer Variablen zur Laufzeit ausführen. Dafür können wir seq 1 1 $n verwenden, wobei n eine Variable sein kann. Siehe das Beispiel:

n=4
for i in $(seq 1 1 $n)
do
    echo -n $i
    echo " "
done

Hier habe ich einer Variablen den Wert 4 zugewiesen, wobei es sich um eine Anzahl handeln kann, z. B. Wortanzahl usw. Siehe Beispielausgabe:

1
2
3
4

Verschachtelte for-Schleife in Bash

Wir haben eine Vielzahl von verschachtelten for-Schleifen in Bash. Entsprechend unserer Anforderung können wir mehrere Variationen der verschachtelten for-Schleifen erstellen (d. h. durch Kombination der verfügbaren for-Schleifenformulierungen.

Hier sehen wir mehrere Beispiele mit der Ausgabe:

  • Geben Sie die ersten zehn Vielfachen der ersten fünf positiven ganzen Zahlen aus.
    for number in {1..5}
    do
    	for n in {1..10}
    	do
    		echo -n $((number*$n))
    		echo -n " "
    	done
    	echo ""
    done
    

    Die Ausgabe dieses Codes ist:

    1 2 3 4 5 6 7 8 9 10
    2 4 6 8 10 12 14 16 18 20
    3 6 9 12 15 18 21 24 27 30
    4 8 12 16 20 24 28 32 36 40
    5 10 15 20 25 30 35 40 45 50
    
  • Drucken Sie die ersten 10 Vielfachen der Liste der ganzen Zahlen.
    for number in 2 5 9
    do
    	for n in {1..10}
    	do
    		echo -n $((number*$n))
    		echo -n " "
    	done
    	echo ""
    done
    

    Die Ausgabe dieses Codes ist:

    2 4 6 8 10 12 14 16 18 20
    5 10 15 20 25 30 35 40 45 50
    9 18 27 36 45 54 63 72 81 90
    
  • Zahlen im Dreiecksmuster drucken.
    for number in {1..5}
    do
    	for n in $(seq 1 1 $number)
    	do
    		echo -n $n
    	done
    	echo ""
    done
    

    Die Ausgabe dieses Codes ist:

    1
    12
    123
    1234
    12345
    

    Wir erhalten möglicherweise mehrere Zeilen aus dem Befehlszeilenargument, um ein Muster mit variabler Größe zu drucken. Siehe Code:

    for number in $(seq 1 1 $@)
    do
    	for n in $(seq 1 1 $number)
    	do
    		echo -n $n
    	done
    	echo ""
    done
    

    Die Ausgabe des Befehls bash pattern2.sh 6 ist:

    1
    12
    123
    1234
    12345
    123456
    

    Wobei patter2.sh der Name dieses Skripts und 6 das Kommandozeilenargument ist.

  • Drucken Sie ein Dreiecksmuster mit einem Sternchen (*) oder einem anderen Zeichen.
    for number in $(seq 1 1 $@)
    do
    	for n in $(seq 1 1 $number)
    	do
    		echo -n "*"
    	done
    	echo ""
    done
    

    Die Ausgabe des Codes mit Argument 4 ist:

    *
    **
    ***
    ****
    
  • Drucken Sie Nachrichten mehrmals (zur Hervorhebung).
    messages="Sea_is_rough Don't_go_too_far_in_the_sea Remain_in_the_group Don't_take_kids_inside"
    for i in 1 2 3 4 5
    do
    	for message in $messages
    	do
    		echo $message
    	done
    	echo "----------------------------------"
    done
    

    Die Ausgabe davon ist:

    Sea_is_rough
    Don't_go_too_far_in_the_sea
    Remain_in_the_group
    Don't_take_kids_inside
    ----------------------------------
    Sea_is_rough
    Don't_go_too_far_in_the_sea
    Remain_in_the_group
    Don't_take_kids_inside
    ----------------------------------
    Sea_is_rough
    Don't_go_too_far_in_the_sea
    Remain_in_the_group
    Don't_take_kids_inside
    ----------------------------------
    Sea_is_rough
    Don't_go_too_far_in_the_sea
    Remain_in_the_group
    Don't_take_kids_inside
    ----------------------------------
    Sea_is_rough
    Don't_go_too_far_in_the_sea
    Remain_in_the_group
    Don't_take_kids_inside
    ----------------------------------
    
  • Drucken Sie das Zählen von 1 bis aufwärts in einer einzigen Zeile. Sie müssen das Zählen bis zur Liste der Befehlszeilenargumente drucken.
    for number in $@
    do
    	for i in $(seq 1 1 $number)
    	do
    		echo -n "$i "
    	done
    	echo ""
    done
    

    Die Ausgabe dieses Codes für Bash counting.sh 4 5 8 ist:

    1 2 3 4
    1 2 3 4 5
    1 2 3 4 5 6 7 8
    
  • Drucken Sie Vielfache von 10 bis 20, aber keine Vielfachen von Primzahlen in dieser Folge.
    for number in $(seq 10 1 20)
    do
    	if [[ $number == 11 || $number == 13 || $number == 17 || $number == 19 ]]
    	then
    		continue
    	fi
    	for n in {1..10}
    	do
    		echo -n $((number*$n))
    		echo -n " "
    	done
    	echo ""
    done
    

    Die Ausgabe dieses Codes ist:

    10 20 30 40 50 60 70 80 90 100
    12 24 36 48 60 72 84 96 108 120
    14 28 42 56 70 84 98 112 126 140
    15 30 45 60 75 90 105 120 135 150
    16 32 48 64 80 96 112 128 144 160
    18 36 54 72 90 108 126 144 162 180
    20 40 60 80 100 120 140 160 180 200
    

Zusammenfassend haben wir eine Vielzahl von verschachtelten for-Schleifen in Bash. Daher können wir Kombinationen der verfügbaren for-Schleifenvarianten gemäß unseren Anforderungen verwenden, um die Aufgabe zu erfüllen.