A while-Schleife ist eine Anweisung, die einen Codeblock durchläuft, bis die angegebene Bedingung als falsch ausgewertet wird. Wir können diese Anweisung oder Schleife in unserem Programm verwenden, wenn wir nicht wissen, wie oft die Bedingung als wahr ausgewertet wird, bevor sie als falsch ausgewertet wird.

Inhaltsverzeichnis

• Die Syntax einer While-Schleife in der BASH-Skripterstellung
• Schleifenbeispiel mit while-Anweisung in Linux
• Lesen einer Datei mit einer While-Schleife
• Endlose While-Schleife
• While-Schleife zum Durchlaufen einer festen Anzahl von Malen
• Lesen Sie das Befehlszeilenargument mit getopts-Optionen
• While-Schleife im C-Stil
• While-Schleife zum Ausführen von Vorgängen an einer Datei
• Mit einer While-Schleife in eine Datei schreiben
• Unterbrechen Sie und fahren Sie mit der while-Schleife fort
• Häufig gestellte Fragen

Die Syntax einer While-Schleife in der BASH-Skripterstellung

while [ condition ]; do  # statements  # commands done 

Wenn die Bedingung wahr ist, werden die Befehle im while-Block ausgeführt und nach Überprüfung der Bedingung erneut iteriert. Auch wenn die Bedingung falsch ist, werden die Anweisungen innerhalb des while-Blocks übersprungen und die Anweisungen nach dem while-Block ausgeführt.

Schleifenbeispiel mit while-Anweisung in Linux

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash

a=7
while [ $a -gt 4 ];
Tun
echo $a
((A-))
Erledigt
echo Aus der Schleife

Erläuterung:

• #!/usr/bin/bash> : Diese Zeile wird Shebang genannt und gibt den Pfad zum Interpreter an, der zum Ausführen des Skripts verwendet werden soll. In diesem Fall wird angegeben, dass die Bash-Shell verwendet werden soll.
• a=7> : Initialisiert eine Variable mit dem Namen a> mit dem Wert 7.
• while [ $a -gt 4 ];> : Startet eine While-Schleife, die so lange andauert, wie der Wert von a> ist größer als 4.
• do> : Markiert den Anfang des Codeblocks, der innerhalb der while-Schleife ausgeführt werden soll.
• echo $a> : Druckt den aktuellen Wert der Variablen a> zur Konsole.
• ((a--))> : Verringert den Wert von a> durch 1. Dies ist eine Kurzschreibweise a=$((a - 1))> .
• done> : Markiert das Ende des Codeblocks für die while-Schleife.
• echo 'Out of the loop'> : Druckt aus der Schleife an die Konsole, nachdem die While-Schleife abgeschlossen ist.

While-Schleife unter Linux

Zusammenfassend initialisiert dieses Skript eine Variable „ a`> mit dem Wert 7, tritt dann in eine while-Schleife ein, die so lange andauert wie ` a`> ist größer als 4. Innerhalb der Schleife wird der aktuelle Wert von ` ausgegeben a`> und dekrementiert es in jeder Iteration um 1. Einmal` a`> 4 oder weniger beträgt, wird die Schleife beendet und das Skript gibt „Out of the loop“ an die Konsole aus.

Lesen einer Datei mit einer While-Schleife

Wir können eine Datei mit einer While-Schleife in BASH lesen. Durch das Parsen bestimmter Parameter für die While-Schleifenbedingung können wir die Datei Zeile für Zeile oder nach anderen Gruppen wie Zeichen oder Wörtern durchlaufen.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash

file=temp.txt
while read -r line;
Tun
echo $line
erledigt <$file

Erläuterung:

• #!/usr/bin/bash> : Diese Shebang-Zeile gibt an, dass die Bash-Shell zur Interpretation des Skripts verwendet werden soll.
• file=temp.txt> : Weist der Variablen die Zeichenfolge temp.txt zu file> , der den Namen der zu lesenden Datei darstellt.
• while read -r line;> : Initiiert eine While-Schleife, die jede Zeile aus der angegebenen Datei liest.
• do> : Markiert den Anfang des Codeblocks, der innerhalb der while-Schleife ausgeführt werden soll.
• echo $line> : Druckt den Inhalt der Variablen line> , das die aktuelle Zeile darstellt, die aus der Datei gelesen wird, an die Konsole.
• done> : Markiert das Ende des Codeblocks für die while-Schleife.
• <'$file'> : Leitet die Eingabe der while-Schleife so um, dass sie aus der angegebenen Datei stammt, in diesem Fall temp.txt.

Zusammenfassend liest dieses Skript jede Zeile aus der Datei temp.txt und gibt sie auf der Konsole aus, bis keine Zeilen mehr in der Datei vorhanden sind. Der -r> Option mit der read> Mit dem Befehl wird sichergestellt, dass Backslashes in der Eingabe als Literalzeichen behandelt werden.

Lesen Sie die Datei mit der while-Anweisung unter Linux

Wir verwenden den Befehl read, um die Zeilen oder Zeichen tatsächlich aus der Datei abzurufen. Der Lesebefehl wird mit dem Argument -r übergeben, das das Escapezeichen von Zeichen ignoriert, wenn das erscheint, und daher als sein geparst wird. Wir lesen eine Zeile aus einer Datei, die nach der done-Anweisung erwähnt wird. Der Lesebefehl liest eine Zeile aus der genannten Datei und die While-Schleifen enden, wenn die letzte Zeile aus der Datei gelesen wurde (es ist keine Zeile mehr zum Lesen übrig).

So können wir den Inhalt der Datei mithilfe einer While-Schleife in BASH lesen.

Endlose While-Schleife

So erstellen Sie eine Endlosschleife mithilfe einer While-Schleifenanweisung. Wir müssen keine Bedingung in die while-Schleife einfügen und daher wird die Schleife unendlich wiederholt. Das Folgende ist das Beispiel einer Endlosschleife:

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash
während :
Tun
echo Eine Endlosschleife
# Wir können Strg + C drücken, um das Skript zu beenden
Erledigt

Erläuterung:

• #!/usr/bin/bash> : Die Shebang-Zeile gibt an, dass die Bash-Shell zur Interpretation des Skripts verwendet werden soll.
• while :> : Initiiert eine Endlosschleife. Der :> (Doppelpunkt) ist ein in die Shell integrierter Befehl, der immer true zurückgibt und so effektiv eine Endlosschleife erzeugt.
• do> : Markiert den Anfang des Codeblocks, der innerhalb der Endlosschleife ausgeführt werden soll.
• echo 'An Infinite loop'> : Gibt die Zeichenfolge „Eine Endlosschleife“ in jeder Iteration der Schleife an die Konsole aus.
• # We can press Ctrl + C to exit the script> : Dies ist ein Kommentar, der darauf hinweist, dass Sie das Skript unterbrechen können, indem Sie im Terminal Strg + C drücken. Strg + C ist eine gängige Methode, um laufende Skripte im Terminal zu unterbrechen und zu beenden.
• done> : Markiert das Ende des Codeblocks für die Endlosschleife.

Zusammenfassend lässt sich sagen, dass dieses Skript eine Endlosschleife erstellt, die kontinuierlich die Meldung „Eine Endlosschleife“ an die Konsole sendet. Durch Drücken von Strg + C im Terminal kann die Schleife unterbrochen und das Skript beendet werden.

Endlosschleife mit While-Anweisung in Linux

Daher wird die while-Schleife im Skript unendlich lange durchlaufen. Wir können die Schleife oder das Skript manuell mit STRG + C unterbrechen.

While-Schleife zum Durchlaufen einer festen Anzahl von Malen

Wir können eine While-Schleife verwenden, um über eine feste Anzahl von Malen zu iterieren. Wir können die Bedingung auf -le oder kleiner als gleich einer Zahl setzen und die Schleife wird iterieren, bis der Iterator kleiner oder gleich der in angegebenen Zahl ist die Bedingung. Außerdem müssen wir den Iterator manuell erhöhen, damit der Schleifeniterator weiterläuft, sonst läuft die Schleife ewig weiter.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash

i=1

# Die Zahl 4 kann die Grenze sein

# iteriere die Schleife

while [ $i -le 4 ];
Tun
echo $i
((i++))
Erledigt

Erläuterung:

• #!/usr/bin/bash> : Die Shebang-Zeile gibt an, dass die Bash-Shell zur Interpretation des Skripts verwendet werden soll.
• i=1> : Initialisiert eine Variable mit dem Namen i> mit dem Wert 1.
• while [ $i -le 4 ];> : Initiiert eine While-Schleife, die so lange andauert, wie der Wert von i> kleiner oder gleich 4 ist.
• do> : Markiert den Anfang des Codeblocks, der innerhalb der while-Schleife ausgeführt werden soll.
• echo $i> : Druckt den aktuellen Wert der Variablen i> zur Konsole.
• ((i++))> : Erhöht den Wert von i> durch 1. Dies ist eine Kurzschreibweise i=$((i + 1))> .
• done> : Markiert das Ende des Codeblocks für die while-Schleife.

while-Schleife unter Linux

Im obigen Beispiel können wir sehen, dass die Schleife eine definierte Anzahl von Malen durchläuft. Da wir den Zähler auf 1 initialisiert haben und die Bedingung darin besteht, die Schleife zu wiederholen, bis der Iterator kleiner oder gleich der Zahl ist, in diesem Fall 4, können wir die Zahl in der Bedingung entsprechend unserer Anforderung ändern.

Lesen Sie das Befehlszeilenargument mit getopts-Optionen

Wir können get ops-Optionen verwenden, um die Eingabe von der Befehlszeile zu lesen. Wenn mehrere Argumente vorhanden sind, können wir sie überprüfen und mithilfe einer While-Schleife einzeln analysieren. getopts ist ein Tool zum Abrufen von Benutzereingaben über die Befehlszeile. Wir können über mehrere Optionen zum Parsen über die Befehlszeile verfügen und mithilfe von getopts und while-Schleifen ein professionell aussehendes Benutzereingabeprogramm erstellen.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/bin/bash

while getopts n:a: OPT
Tun
Fall ${OPT} in
n) name=${OPTARG} ;;
a) alter=${OPTARG} ;;
*) echo Ungültige Option
Ausgang 1 ;;
esac
Erledigt
printf Mein Name ist $name und ich bin $age Jahre alt

Erläuterung:

• #!/bin/bash> : Die Shebang-Zeile gibt an, dass die Bash-Shell zur Interpretation des Skripts verwendet werden soll.
• while getopts n:a: OPT> : Initiiert eine Schleife, die verwendet getopts> um Befehlszeilenoptionen zu analysieren. Die angegebenen Optionen sind n> Und a> , auf die beide ein Argument folgen soll.
• do> : Markiert den Anfang des Codeblocks, der innerhalb der Schleife ausgeführt werden soll.
• case '${OPT}' in> : Startet eine Case-Anweisung, die den Wert der von gefundenen Option auswertet getopts> .
• n) name=${OPTARG};;> : Wenn die Option ist -n> , weist der Variablen den Wert des entsprechenden Arguments zu name> .
• a) age=${OPTARG};;> : Wenn die Option ist -a> , weist der Variablen den Wert des entsprechenden Arguments zu age> .
• *) echo 'Invalid option'> : Wenn eine ungültige Option gefunden wird, wird eine Fehlermeldung an die Konsole ausgegeben.
• exit 1;;> : Beendet das Skript mit einem Statuscode ungleich Null, was auf einen Fehler hinweist.
• esac> : Beendet die case-Anweisung.
• done> : Markiert das Ende des Codeblocks für die Schleife.
• printf 'My name is $name and am $age years old '> : Druckt eine formatierte Nachricht mit den Werten von ` an die Konsole name`> und ` age`> wird über die Befehlszeilenoptionen abgerufen.

While-Schleife unter Linux

In diesem Fall haben wir zwei Optionen, nämlich den Namen und das Alter. Sie können mehrere Optionen wählen. Wir müssen angeben, welche Option wir in den Switch-Case-Anweisungen und in der Befehlszeile mit der Option -shorthand verwenden möchten. In diesem Fall haben wir verwendet -n für Namen Und -a für das Alter . Wir verfügen außerdem über eine Standard- oder Ungültigkeitsprüfung, um sicherzustellen, dass falsche Argumente nicht analysiert werden. Wir können den Wert der Option mithilfe von zuweisen OPTARG Variable, die den für die Option bereitgestellten Wert analysiert.

Die while-Schleife wird hier verwendet, um zu iterieren, bis keine Optionen mehr von der Befehlszeile übergeben werden. Wir suchen nach den Optionen -n und -a und iterieren, bis der Wagenrücklauf oder die Eingabetaste gedrückt wird und keine weiteren Optionen zum Parsen vorhanden sind.

While-Schleife im C-Stil

Wir können eine While-Schleife im C-Stil in BASH verwenden. Die Variablen müssen im BASH-Stil ausgewertet werden, aber die Gesamtsyntax ähnelt C. Wir können Operatoren wie , <= usw. in der Bedingung der While-Schleife und damit verwenden wird wie die C-förmige while-Schleife aufgerufen.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim c-style-while.sh 

#!/bin/bash
ich=0
while ((i <12))
Tun
echo $i
((i+=2))
Erledigt

c-style-while

In diesem Beispiel können wir sehen, dass die while-Schleife eine Bedingung mit Nicht-Bash-Operatoren wie -le, -ge usw. hat. Stattdessen verwenden wir in der Bedingung Operatoren im C-Stil. Der Rest der Schleife ist die Basisschleife wie in BASH, die Variable oder der Iterator i wird um zwei erhöht, wie wir in der letzten Anweisung des Schleifenkörpers sehen können. Somit wird die Schleife fünfmal wiederholt.

While-Schleife zum Ausführen von Vorgängen an einer Datei

Wir können Operationen an einer Datei ausführen, z. B. nur einen bestimmten Teil einer Datei lesen. Wenn wir Spalten haben, die auf eine bestimmte Weise formatiert sind, können wir sie mithilfe von Variablen zuweisen und eine Datenzeile lang ausdrucken.

Hier ist der Beispieldateiname wh.txt

vim wh.txt 

Wir erstellen eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim file-while.sh 

Sprachtyp freigegeben

Python allgemein 1991

Javascript-Web 1995

Java Mobile 1995

Rust eingebettet 2010

Gehen Sie zum Backend 2007

Wir erstellen eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim file-while.sh 

#!/bin/bash

während a b c gelesen wird
Tun
echo $b – $a
Erledigt

While-Schleife unter Linux

In diesem Beispiel haben wir drei Zeilen. Wir lesen den Inhalt, indem wir ihn den Variablen a, b und c zuweisen. Es kann alles sein, was Sie möchten, aber denken Sie daran, sie im Schleifenkörper zu verwenden. Wir können eine bestimmte Spalte wie b und a auswählen und sie drucken oder beliebige Operationen darauf ausführen. Dies wird jedoch nicht in der Datei widergespiegelt, da es sich lediglich um lokale Skriptvariablen handelt.

Mit einer While-Schleife in eine Datei schreiben

Wir können durch Benutzereingaben in einer While-Schleife in eine Datei schreiben. Wir können die while-Schleife verwenden, um zu iterieren, bis wir die Schleife manuell verlassen, indem wir STRG + D verwenden, um Änderungen in der Datei zu speichern, oder STRG + C verwenden, um das Schreiben in die Datei zu vermeiden. Wir verwenden den Lesebefehl, um den Text über die Befehlszeile einzugeben und ihn in die Datei zu analysieren.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim write-wh.sh 

#! /bin/bash

file=wh.txt
echo Geben Sie den Inhalt in die Datei $file ein
während Zeile gelesen
Tun
echo $line>> $file
Erledigt

while-Schleife unter Linux

Aus dem obigen Beispiel konnten wir mithilfe einer While-Schleife und eines Lesebefehls Text in eine Datei eingeben. Um die Schleife zu verlassen und Änderungen an der Datei zu speichern, verwenden wir die Tasten STRG+D, und um die Schleife zu verlassen, ohne etwas in der Datei zu speichern, können wir die Tasten STRG+C verwenden. Dazu geben wir den Text von der Kommandozeile aus mit dem Lesebefehl und einer While-Schleife in die Textdatei ein.

Unterbrechen Sie und fahren Sie mit der while-Schleife fort

Break und continue sind in einem Programm, das Schleifenanweisungen verarbeitet, von wesentlicher Bedeutung, da sie den Ablauf der Schleifenanweisungen ohne explizite Bedingungen steuern.

Break-Anweisung in While-Schleife

Wir verwenden Break-Anweisungen, um die Schleife zu verlassen, ohne darauf zu warten, dass die Bedingung der While-Schleife „falsch“ ergibt. Diese Anweisung kann innerhalb eines Schleifenblocks verwendet werden. Dies kann verwendet werden, um eine Endlosschleife mit einer programmgesteuerten Bedingung innerhalb der Schleife zu verlassen und so die Kontrolle über die Schleife zu behalten.

Wir haben zum Beispiel ein Skript, das von 1 bis in alle Ewigkeit zählt. Wir können die Schleife jedoch programmgesteuert verlassen, indem wir eine break-Anweisung innerhalb des Schleifenkörpers mit einer Bedingung verwenden.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash

i=1
während :
Tun
echo $i
if [ $i -eq 20 ]; Dann
echo Dies ist das Ende der Schleife
brechen
Sei
((i++))
Erledigt

Break-Anweisung während der Schleife in Linux

Anhand des Skripts und der Ausführung können wir erkennen, dass wir mit einer bedingten Anweisung und der break-Anweisung eine Endlosschleife unterbrechen oder verlassen konnten. Daher wird die break-Anweisung verwendet, um den Kontrollfluss eines Programms/Skripts innerhalb einer while-Schleife zu erhalten, um aus der Schleife auszubrechen, ohne dass die Schleifenbedingung als falsch ausgewertet wird.

Continue-Anweisung in While-Schleife

Mit der continue-Anweisung können wir das Gegenteil der break-Anweisung bewirken. Es springt zum Anfang des Schleifenblocks und wiederholt die Schleife. Dies kann zum Überspringen bestimmter Befehle unter bestimmten Bedingungen verwendet werden und ermöglicht so eine Änderung des Schleifenablaufs.

Wenn wir beispielsweise eine Variable auf 1 initialisiert haben und nur die durch fünf teilbaren Zahlen oder in einem bestimmten Muster nach einer Bedingung anzeigen möchten, können wir dazu Continue-Anweisungen verwenden. Dies ermöglicht die Iteration über die Schleife in der gewünschten Weise.

Zuerst erstellen wir eine Textdatei mit einem Texteditor unter Linux, in diesem Fall verwenden wir den Texteditor „vim“.

vim while.sh 

#!/usr/bin/bash

i=1
while [ $i -lt 30 ];
Tun
((i++))
if [[ $(( $i % 5 )) -ne 0 ]];
Dann
weitermachen
Sei
echo $i
Erledigt

Continue-Anweisung in der While-Schleife unter Linux

Wie wir sehen können, springt die continue-Anweisung zum Anfang des Blocks und startet die Ausführung der Befehle, indem sie die nächsten Befehle innerhalb des Blocks überspringt. Die while-Schleife iteriert nur für den Wert von Variable i kleiner als 30 ist, prüft die if-Bedingung, ob die Variable i ist durch 5 teilbar, und wenn nicht, iterieren wir noch einmal mit continue und erhöhen den Wert der Variablen i. Der Variable i wird nur dann wiedergegeben, wenn es durch 5 teilbar ist. Daher wird die if-Bedingung als „falsch“ ausgewertet und wir stoßen nicht auf eine continue-Anweisung und führen den normalen Ablauf der Schleife durch. Dies geschieht, um die Protokollierung jeder Zahl zu vermeiden und nur die Zahlen auszugeben, die keinem Muster oder einer Bedingung in der if-Anweisung oder anderen bedingten Anweisungen folgen.

Häufig gestellte Fragen

1. Was ist ein ` while`> Schleife im Bash-Scripting?

A while> Schleife ist eine Kontrollflussanweisung in der Bash-Skripterstellung, die die wiederholte Ausführung eines bestimmten Codeblocks ermöglicht, solange eine bestimmte Bedingung wahr ist. Die Schleife bietet eine Möglichkeit, sich wiederholende Aufgaben zu automatisieren und ist ein grundlegendes Konstrukt in der Skripterstellung und Programmierung.

2. Wie funktioniert die Syntax eines ` while`> Loop-Look in Bash?

Die grundlegende Syntax von a while> Schleife in Bash ist wie folgt:

while [ Bedingung ]
Tun
# Code, der ausgeführt werden soll, solange die Bedingung wahr ist
Erledigt

Das ` condition`> ist ein Test, der vor jeder Iteration der Schleife durchgeführt wird. Wenn die Bedingung wahr ist, wird der Code innerhalb der Schleife ausgeführt. Wenn die Bedingung falsch ist, wird die Schleife beendet und das Skript fährt mit dem nächsten Befehl nach dem ` fort done`> Stellungnahme.

3. Welche Rolle spielt das ` (( ... ))`> in einem Bash konstruieren while> Schleife?

Das ` (( ... ))`> Das Konstrukt in Bash wird für arithmetische Operationen verwendet. Im Rahmen eines ` while`> Schleife wird häufig zur Auswertung arithmetischer Bedingungen eingesetzt.

Zum Beispiel: ` ((i <10))> `> prüft, ob die Variable ` i`> ist kleiner als 10. Dadurch können Sie arithmetische Ausdrücke direkt in der Schleifenbedingung verwenden, was es besonders nützlich macht, wenn es um numerische Vergleiche geht.

4. So erstellen Sie eine Endlosschleife mit „ while`> in Bash?

Eine Endlosschleife in Bash kann erstellt werden, indem eine Bedingung angegeben wird, die immer als wahr ausgewertet wird.

Zum Beispiel:

zwar wahr
Tun
# Code für die Endlosschleife
Erledigt

Alternativ können Sie in der Bedingung eine Konstante ungleich Null verwenden, z ` while [ 1 ]`> , um das gleiche Ergebnis zu erzielen. Endlosschleifen sind in Situationen nützlich, in denen eine kontinuierliche Ausführung erforderlich ist, bis sie manuell unterbrochen wird.

Abschluss

In diesem Artikel haben wir die BASH-Scripting-while-Schleife besprochen, die sich als vielseitiges Werkzeug zum wiederholten Ausführen eines Codeblocks basierend auf einer bestimmten Bedingung erweist. Die grundlegende Syntax besteht darin, die Bedingung in eckigen Klammern zu definieren, was flexible Iterationen ermöglicht. Der Artikel untersucht verschiedene Anwendungen von While-Schleifen, darunter das Lesen aus Dateien, das Erstellen von Endlosschleifen, festen Iterationen, das Parsen von Befehlszeilenargumenten und die Verwendung von Break- und Continue-Anweisungen. Von der Syntax im C-Stil bis zum interaktiven Schreiben von Dateien zeigt jedes Beispiel die Anpassungsfähigkeit der Schleife bei der Erfüllung einer Reihe von Skriptanforderungen. Dieser umfassende Überblick unterstreicht die Bedeutung der While-Schleife in der BASH-Skripterstellung, da sie einen robusten Mechanismus für kontrollierte Wiederholung und effiziente Codeausführung bietet.