Programmierung & Skripten

Schleifen mit Beispielen verprügeln

1687
497
Ilja Köpernick

Bereit, in Bash -Looping zu tauchen? Mit der Popularität von Linux als kostenloses Betriebssystem und mit der Leistung der Bash -Befehlszeilenschnittstelle bewaffnet, kann man noch weiter gehen und erweiterte Schleifen direkt aus der Befehlszeile oder in Bash -Skripten codieren.

Wenn man diese Kraft nutzen, kann man jedes Dokument, alle Dateien manipulieren oder erweiterte Algorithmen von fast jeder Art und jedem Geschmack implementieren. Es ist unwahrscheinlich.

Das heißt, Bash -Loops können manchmal schwierig in Bezug auf Syntax sein und umgebende Wissen ist von größter Bedeutung. Heute präsentieren wir Ihnen eine Reihe von Bash -Loop! Lass uns anfangen!

In diesem Tutorial lernen Sie:

Wie verprügeln für, während Und bis Basierte Schleifen funktionieren mit Beispielen
Wie Bash die Beendigung von Schleifenstartanweisungen erfordert, bevor der Abschnitt der Schleife erfolgt, kann dies folgen und wie sich dies mit iF und anderen Aussagen bezieht
So implementieren Sie grundlegende und mittlere erweiterte Bash -Schleifen
Wie Subschalen funktionieren und wie sie in Bash -Schleifen -Umfangserklärungen verwendet werden können
So starten Sie defensiv Schleifen und vermeiden Sie Fehler in der Ausgabe
Wie man codiert Einzeiler (Ein gemeinsamer Begriff, der unter Bash -Entwicklern verwendet wird) in der Befehlszeile im Vergleich zu denselben Code in einem Bash -Skript implementieren
Wie zum ; Die Syntax -Idiom ist eine wichtige Angelegenheit, wenn es darum geht, Bash -Loops sowohl in der Befehlszeile als auch in Skripten zu codieren

Bash Scripting - Schleifen mit Beispielen verprügeln

Bash Loops Beispiele

Beginnen wir mit einem Basis für Schleife:
```
$ für i in $ (SEQ 1 5); echo $ i; fertig 1 2 3 4 5
```
Kopieren
Wie Sie sehen können, grundlegend für Schleifen in Bash sind relativ einfach zu implementieren. Hier sind die Schritte:

für: Gibt an, dass wir eine neue für basierte Schleife starten möchten
ich: Eine Variable, mit der wir den von der Klausel in der Klausel generierten Wert speichern können In Schlüsselwort (nämlich die Sequenz direkt unten)
$ (SEQ 1 5): Dies führt einen Befehl in einer anderen Unterschale aus.

Um zu verstehen, wie dies funktioniert, betrachten Sie dieses Beispiel:
```
$ SEQ 1 5 1 2 3 4 5
```
Kopieren
Grundsätzlich das $ () Syntax kann wann immer (und wo auch immer!) Sie möchten eine neue Unterschale starten. Dies ist eines der mächtigsten Merkmale der Bash -Shell. Betrachten Sie zum Beispiel:
```
$ CAT -Test.txt 1 2 $ echo "$ (CAT -Test.txt | Kopf -n1) "1
```
Kopieren

Wie Sie sehen können, wurde hier der Subshell "Katzentest durchgeführt".txt | Head -n1 '(' Head -n1 'wählt nur die erste Zeile aus) und dann die Ausgabe dieser Unterschale wiederholt.

Lassen Sie uns weiterhin unsere für die Schleife oben analysieren:

;: Dies ist sehr wichtig. In Bash, jede „Aktion“, wie zum Beispiel eine 'für' Schleife Start oder einen 'if' Anweisungstest oder eine Weile Schleife usw. muss mit einem ';' 'beendet werden. Und so kam es dass der ';' ist hier * vor * das do, nicht danach. Betrachten Sie dieses sehr ähnlich, wenn Beispiel:
```
$ wenn ["a" == "a"]; dann echo "ja!"; fi ja!
```
Kopieren
Beachten Sie, wie wieder die ; ist vor dem Dann, nicht danach. Bitte lassen Sie sich nicht von Ihnen beim Scripting für oder während der Schleifen verwirren, wenn Aussagen usw. Denken Sie nur daran, dass jede Aktion vor einer neuen Aktion beendet werden muss, und so für oder Wenn muss vor der nächsten Aktion beendet werden, die in dem Beispiel für iF -Anweisungen "dann" ist, und Tun in der für Schleife oben!

Schließlich haben wir:

Tun: Anzeigt, dass für Was kommt vorher? … Tun… Was kommt jenseits. Beachten Sie noch einmal, dass dieses Aktionswort nach dem Schließen erfolgt ; Wird verwendet, um die für die Schleifenöffnungsanweisung zu schließen.
echo $ i: Hier geben wir den in die gespeicherten Wert aus ich variabel ($ i)
;: Beenden Sie die Echo -Erklärung (beenden Sie jede Aktion)
Erledigt: Geben Sie an, dass dies das Ende unserer Schleife ist
Nehmen wir das gleiche Beispiel, schreiben wir es jedoch anders:
```
$ für i in 1 2 3 4 5; echo $ i; fertig 1 2 3 4 5
```
Kopieren
Sie können jetzt sehen, wie sich dies auf das obige Beispiel bezieht. Es ist der gleiche Kommentar, obwohl wir hier keine Unterschale verwendet haben, um eine Eingangssequenz für uns zu generieren, haben wir sie selbst manuell angegeben.

Setzt dies Ihren Kopf ab, um mögliche zu rennen? Also sollte es jetzt etwas Cooles damit machen.
Erhöhen Sie die Komplexität unserer für Schleife, um Dateien einzuschließen:
```
$ ls 1.txt 2.txt 3.TXT 4.txt 5.txt
```
Kopieren
```
$ head -n1 *.txt ==> 1.txt <== 1 ==> 2.txt <== 1 ==> 3.txt <== 1 ==> 4.txt <== 1 ==> 5.txt <== 1 
```
Kopieren
```
$ für i in $ (ls *.txt); machen Katze "$ i" | Kopf -n1; fertig 1 1 1 1 1
```
Kopieren
Können Sie herausfinden, was hier passiert?? Wenn wir uns die neuen Teile davon für Loop ansehen, sehen wir:
$ (ls *.txt): Dadurch werden alle TXT -Dateien im aktuellen Verzeichnis aufgelistet und beachten ich Variable, eine Datei pro/für jede Schleife die für Schleife läuft durch.

Mit anderen Worten, das erste Mal, dass die Schleife (der Teil zwischen do und getan) passiert, $ i wird beinhalten 1.txt. Der nächste Lauf $ i wird beinhalten 2.txt usw.

Katze "$ i" | Kopf -n1: Hier nehmen wir das $ i Variable (wie wir gesehen haben, wird dies sein 1.txt, gefolgt von 2.txt usw.) und Katze, diese Datei (anzeigen) und die erste Zeile derselben nehmen Kopf -n1. Also 5 mal 1 wird ausgegeben, da dies die erste Zeile in allen 5 Dateien ist, wie wir aus dem Prior sehen können Kopf -n1 über alles .TXT -Dateien.
Wie wäre es jetzt mit einem sehr komplexen?
```
 $ tail -n1 *.txt ==> 1.txt <== 1 ==> 2.txt <== 2 ==> 3.txt <== 3 ==> 4.txt <== 4 ==> 5.txt <== 5 
```
Kopieren
```
$ für i in $ (ls *.txt 2>/dev/null); echo -n "$ (Tail -n1 $ i)"; echo "von $ i !";;.txt ! 2 von 2.txt ! 3 von 3.txt ! 4 von 4.txt ! 5 ab 5.txt ! 
```
Kopieren
Können Sie trainieren, was hier passiert??

Lassen Sie es uns Schritt für Schritt analysieren.

Denn ich in : Wir wissen das bereits; neu starten für Schleife, zuweisen Sie Variable i an alles, was in der folgt In Klausel
$ (ls *.txt 2>/dev/null): Das gleiche wie der obige Befehl; Listen Sie alle TXT-Dateien auf, diesmal jedoch mit ein wenig definitivem fehlerverleugendem Schutz. Sehen:
```
$ für mich in $ (ls i.Tun.nicht.existieren); wiederholt "nur die Nichteinheit von Dateien testen"; Fertig LS: Ich kann nicht zugreifen 'i.Tun.nicht.existieren ': Keine solche Datei oder Verzeichnis 
```
Nicht sehr professionelle Ausgabe! Daher;
```
$ für mich in $ (ls i.Tun.nicht.existieren 2>/dev/null); wiederholt "nur die Nichteinheit von Dateien testen"; Erledigt 
```
Diese Aussage wird keine Ausgabe generiert.

Lassen Sie uns unsere Analyse fortsetzen:

; Tun: Beenden Sie die For -Schleifen -Startanweisung und beginnen
echo -n "$ (Tail -n1 $ i)";: Erstens die -N steht für Stellen Sie die nachfolgende Newline am Ende der angeforderten Ausgabe nicht aus.

Als nächstes nehmen wir die letzte Zeile jeder Datei ein. Beachten Sie, wie wir unseren Code von oben optimiert haben? ich.e. anstatt zu tun Katzendatei.txt | Schwanz -n1 Man kann einfach tun Tail -n1 -Datei.txt - eine Kurzform, die neue Bash -Entwickler leicht vermissen können. Mit anderen Worten, hier drucken wir einfach 1 (die letzte Zeile in 1.txt) sofort gefolgt von 2 für 2.txt usw.

Wenn wir den Befehl für Follow -up -Echo nicht angegeben hätten, wäre die Ausgabe einfach gewesen, wenn wir nicht angegeben hätten, einfach gewesen 12345 Ohne Neulinge:
```
$ für i in $ (ls *.txt 2>/dev/null); echo -n "$ (Tail -n1 $ i)"; erledigt 12345 $
```
Kopieren
Beachten Sie, wie selbst die letzte Newline nicht vorhanden ist, daher die Ausgabe vor der Eingabeaufforderung $ kehrt zurück.

Endlich haben wir echo "von $ i !"; (zeigt uns die von 1.txt ! Ausgabe) und die Schließung der Schleife durch die Erledigt.

Ich vertraue jetzt, dass Sie inzwischen sehen können, wie leistungsfähig dies ist und wie viel Kontrolle man über Dateien, Dokumentinhalte und mehr ausüben kann!

Generieren wir als nächstes eine lange zufällige Zeichenfolge mit einer Weile Schleife! Spaß?

Verwenden Sie eine Weile Schleife, um eine zufällige Zeichenfolge zu generieren:

$ Random = "$ (Datum +%s%n | Cut -b14-19)" $ count = 0; Myrandom =; während wahr; do count = $ [$ count + 1]; if [$ count -Gt 10]; dann brechen; fi; Myrandom = "$ myrandom $ (echo" $ random "| sed 's |^\ (.\).*| \ 1 | ') "; erledigt; echo" $ Myrandom "6421761311

Kopieren

Das sieht komplex aus! Lassen Sie es uns Schritt für Schritt analysieren. Aber zuerst sehen wir sehen, wie dies in einem Bash -Skript aussehen würde.

Beispiel für dieselbe Funktionalität, implementiert in einem Bash -Skript:
```
$ CAT -Test.Sch #!/bin/bash random = "$ (Datum +%S%N | Cut -b14-19)" count = 0 myrandom = while true; do count = $ [$ count + 1] if [$ count -Gt 10]; dann brechen Sie fi myrandom = "$ myrandom $ (echo" $ random "| sed 's |^\ ((.\).*| \ 1 | ') "Done Echo" $ Myrandom "
```
Kopieren
```
$ chmod +x Test.Sh $ ./prüfen.SH 1111211213 $ ./prüfen.Sh 1212213213 
```
Es ist manchmal ziemlich überraschend, dass ein solcher komplexer Bash-Looping-Code so leicht in einen „Ein-Liner“ verlegt werden kann (ein Begriff, mit dem Entwickler auf das Verweisen auf das Realität ein kleines Skript verweisen, das jedoch direkt aus der Befehlszeile implementiert ist, normalerweise auf einem einzelne (oder maximal einige) Linien.

Lassen Sie uns nun unsere letzten beiden Beispiele analysieren - die sehr ähnlich sind. Die kleinen Codeunterschiede, insbesondere um die Idiom ';' '; werden erklärt in Beispiel 7 unter:

Random = "$ (Datum +%S%N | Cut -b14-19)" In Zeile 4: Dies dauert (mit Verwendung Schnitt -b14-19) Die letzten 6 Ziffern der aktuellen Epochenzeit (die Anzahl der Sekunden, die seit dem 1. Januar 1970 vergangen sind) wie von gemeldet Datum +%s%n und weist diese generierte Zeichenfolge der zufälligen Variablen zu und setzt damit eine halbfristige Entropie in den zufälligen Pool, in einfachen Worten "Der Zufallspool etwas zufälliger zu machen".
Count = 0 In Zeile 6: Stellen Sie die ein ZÄHLEN variabel zu 0
Myrandom = In Zeile 7: Stellen Sie die ein Myrandom Variable zu "leer" (kein Wert zugewiesen)
während ... tun ... fertig Zwischen Zeile 9 und Zeile 15: Dies sollte jetzt klar sein; Beginnen Sie eine Weile Schleife, führen Sie den Code zwischen den DO -DEFT -Klauseln aus.
WAHR: Und solange die Aussage, die dem 'THE' folgt, als wahr bewertet wird, wird die Schleife fortgesetzt. Hier ist die Aussage "wahr", was bedeutet, dass dies eine unbestimmte Schleife ist, bis a brechen Aussage wird gegeben.
Count = $ [$ count + 1] In Zeile 10: Erhöhen Sie unsere ZÄHLEN Variable durch 1
if [$ count -Gt 10]; Dann In Zeile 11: Eine IF -Anweisung, um zu überprüfen, ob unsere Variable größer ist, dann ist -GT 10, Und wenn ja, führen Sie die dann aus .. fi Teil
brechen In Zeile 12: Dies wird die unbestimmte Zeit während der Schleife brechen (ich.e. Wenn ZÄHLEN ist dann größer 10 Die Schleife endet)
Myrandom = ".. In Zeile 14: Wir werden einen neuen Wert zuweisen Myrandom
$ Myrandom In Zeile 14: Nehmen Sie zunächst das, was wir bereits haben
$ (echo "$ random" | sed 's |^\ (.\).*| \ 1 | ') In Zeile 14: Dies ist der Teil, der jedes Mal hinzugefügt wird. Grundsätzlich wiederholt es das WILLKÜRLICH Variable und nimmt das erste Zeichen dieser Ausgabe unter Verwendung eines komplexen regulären Ausdrucks in SED auf. Sie können diesen Teil ignorieren, wenn Sie möchten, im Grunde genommen heißt es: "Nehmen Sie den ersten Charakter der $ Zufällig variable Ausgabe und alles andere wegwerfen "

Sie können also sehen, wie die Ausgabe (zum Beispiel 1111211213) wird erzeugt; Ein Charakter (von links nach rechts) zu dieser Zeit mit der while-Schleife, welche Schleife 10 Zeiten als Ergebnis der ZÄHLEN Gegenvariableprüfung.

Warum ist die Ausgabe oft im Format von 1,2,3 und weniger andere Zahlen? Das liegt daran, dass die WILLKÜRLICH Die Variable gibt eine halbbewegliche Variable zurück (basierend auf dem Zufällig =… Samen), der im Bereich von 0 bis 32767 liegt. Daher beginnt diese Zahl häufig mit 1, 2 oder 3. Zum Beispiel kehren 10000-19999 zurück in 1 usw. als erster Charakter der Ausgabe wird immer von der SED genommen!
Ein kurzes Skript, um die Möglichkeit zum Anordnen (oder Stil-) Schleifencode auf eine andere Weise hervorzuheben, ohne die zu verwenden ; Idiom.
Wir müssen die kleinen Unterschiede des Bash-Skripts im Vergleich zu dem Befehlszeilenskript von One-Liner klarstellen.
NOTIZ
Beachten Sie das im Bash -Skript (Test.Sh) Es gibt nicht so viele ; Redewendungen. Dies liegt daran, dass wir den Code jetzt über mehrere Zeilen geteilt haben und a ; Ist nicht erforderlich, wenn stattdessen ein EOL -Zeichen (Ende der Linien-) Zeichen vorliegt. Ein solcher Charakter (Newline- oder Wagenrendite) ist in den meisten Texteditors nicht sichtbar, aber es ist selbsterklärend, wenn Sie darüber nachdenken, dass sich jeder Befehl in einer separaten Zeile befindet.
Beachten Sie auch, dass Sie das platzieren können Tun Klausel der während Schleifen Sie auch in der nächsten Zeile, so dass es unnötig wird, das überhaupt zu verwenden ; Dort.
```
$ cat test2.Sch #!/bin/bash für i in $ (seq 1 3) echo "... Schleife ... $ ich ..." fertig
```
Kopieren
```
$ ./test2.Sh… Looping… 1… Schleifen… 2… Looping… 3… 
```
Ich persönlich bevorzuge den Syntaxstil, der in angegeben ist Beispiel 6, Wie es klarer erscheint, wie die Absicht des Code ist, die Schleifenanweisung vollständig in einer Zeile (gleichermaßen an andere Codierungssprachen) zu schreiben, obwohl sich Meinungen und Syntaxstile pro Entwickler oder pro Entwicklergemeinschaft unterscheiden.
Schauen wir uns schließlich eine Bash an, bis 'Loop:
```
$ Nr = 0; bis [$ nr -eq 5]; echo "$ nr"; Nr = $ [$ nr + 1]; fertig 0 1 2 3 4
```
Kopieren
Lassen Sie uns dieses Beispiel analysieren:

Nr = 0: Hier legen Sie eine Variable mit dem Namen fest Nr, bis Null
bis: Wir beginnen unsere 'bis' Schleife
[$ Nr -eq 5]: Das ist unser Wenn Zustand oder besser unsere bis Zustand. ich sage Wenn Da die Syntax (und die Arbeit) der des Testbefehls ähnlich ist, ist ich.e. Der Unterlagenbefehl, der in verwendet wird in Wenn Aussagen. In Bash kann der Testbefehl auch durch Single dargestellt werden ["] Klammern. Der $ Nr -eq 5 Testmittel; wenn unsere Variable Nr erreicht 5, dann wird der Test wahr, was wiederum das macht bis Loop -Ende, wenn die Bedingung übereinstimmt (eine andere Möglichkeit, dies zu lesen, ist wie "bis wahr" oder "bis unsere NR -Variable 5" entspricht). Beachten Sie, dass der Loop -Code nicht mehr ausgeführt wird, sobald NR 5 ist, also ist 4 die letzte angezeigte Zahl.
;: Beenden Sie unsere bis oben erläuterte Erklärung
Tun: Starten Sie unsere Aktionskette, die ausgeführt werden soll, bis die getestete Anweisung wahr/gültig wird
echo "$ nr;": Echo aus dem aktuellen Wert unserer Variablen Nr
Nr = $ [$ nr + 1];: Erhöhen Sie unsere Variable um eins um eins. Der $ ['...'] Die Berechnungsmethode ist spezifisch zu verprügeln
Erledigt: Beenden Sie unseren Aktionsketten-/Loop -Code

Wie Sie sehen können, während und bis Schleifen in der Natur sehr ähnlich sind, obwohl sie tatsächlich Gegensätze sind. Während Schleifen ausführen, solange etwas wahr/gültig ist, während Schleifen ausgeführt werden, solange etwas "noch nicht gültig/wahr ist" ist. Oft sind sie austauschbar, indem sie den Zustand umkehren.

Abschluss

Ich vertraue darauf, dass Sie anfangen können, die Kraft von Bash zu sehen, und insbesondere für, während und bis Bash Loops. Wir haben hier nur die Oberfläche zerkratzt, und ich kann später mit weiteren fortgeschrittenen Beispielen zurück sein. Lassen Sie uns in der Zwischenzeit einen Kommentar darüber, wie Sie Bash-Schleifen in Ihren täglichen Aufgaben oder Skripten verwenden. Genießen!

Schleifen mit Beispielen verprügeln

Bash Loops Beispiele

Abschluss

Verwandte Linux -Tutorials:

Beste Artikel

12 Beste Linux -Serververteilungen von 2023

Dieser Artikel zeigt die Top 12 Linux -Serververteilungen basierend auf Rechenzentrumsfunktionen und...

Die besten Linux -Verteilungen für Anfänger im Jahr 2023

Die Open-Source-Community hat enorme Anstrengungen unternommen, um Linux näher an die normalen Windo...