De veelzijdige Bash for loop doet veel meer dan een bepaald aantal keren rondlopen. We beschrijven de vele varianten, zodat je ze met succes in je eigen Linux-scripts kunt gebruiken.
De voor Loop
Alle script- en programmeertalen hebben een manier om met loops om te gaan. Een lus is een stuk code dat u herhaaldelijk wilt laten uitvoeren. In plaats van steeds weer dezelfde set instructies in uw script te typen, zal een lus een deel van de code keer op keer voor u herhalen.
De bash for lus is zeer flexibel. Het kan werken met getallen, woorden, arrays, opdrachtregelvariabelen of de uitvoer van andere opdrachten. Deze worden gebruikt in de koptekst van de lus. De kop dicteert waarmee de lus werkt, bijvoorbeeld cijfers of tekenreeksen, en wat de eindvoorwaarde is die de lus stopt.
De lichaam van de lus bevat de code die u wilt laten herhalen. Het bevat wat je wilt dat de lus bevat doen. De hoofdtekst van de lus kan elke geldige scriptopdracht bevatten.
Een variabele genaamd de lusteller of iterator wordt gebruikt om door een reeks waarden of een lijst met gegevensitems te bladeren. Voor elke lus neemt de iterator de waarde aan van het volgende getal, de volgende tekenreeks of welk gegevenstype dan ook waarover de lus itereert. Hierdoor kan de lus om de beurt werken met de waarden van elk van de data-items, of zelfs in sommige gevallen om de data-items zelf te manipuleren.
Eenvoudig voor lussen
Als u uw eerste for-lus wilt schrijven, helpen deze eenvoudige voorbeelden u op weg.
voor lussen met behulp van numerieke lijsten
Je kunt rennen for lus op de opdrachtregel. Deze opdracht maakt en voert een eenvoudige for lus. De iterator is een variabele genaamd i. We gaan toewijzen i om beurtelings elk van de waarden in de lijst met getallen te zijn. Het lichaam van de lus gaat die waarde naar het terminalvenster afdrukken. De voorwaarde die deze lus beëindigt, is wanneer i heeft de hele lijst met getallen herhaald.
for i in 1 2 3 4 5; do echo $i; done
Het is belangrijk om hier op te merken dat de variabele i wordt elke keer dat de lus ronddraait met één verhoogd, maar dat komt omdat de lijst met getallen elke keer met één omhoog gaat.
Deze lijst met getallen begint bij 3 en gaat in stappen van twee omhoog en springt vervolgens willekeurig naar 44.
for i in 3 5 7 9 11 44; do echo $i; done
Het maakt geen verschil voor de for lus. Het begint aan het ene uiteinde van de lijst en gebruikt elke waarde om de beurt, totdat alle waarden in de lijst zijn gebruikt.
De nummers hoeven ook niet in oplopende volgorde te staan. Ze kunnen in elke volgorde staan.
for i in 3 43 44 11 9; do echo $i; done
for Loops met behulp van woordenlijsten
We kunnen net zo gemakkelijk hetzelfde doen met woorden. Kopieer de tekst van het script naar een editor en sla het op als “word-list.sh.”
#!/bin/bash for word in This is a sequence of words do echo $word done
Je moet gebruiken chmod om het script uitvoerbaar te maken, en elk ander script dat u uit dit artikel kopieert. Vervang gewoon de naam van het script elke keer dat u de . gebruikt chmod opdracht.
chmod +x word-list.sh
Laten we het script uitvoeren.
./word-list.sh
Net als bij de getallen, de iterator – in dit voorbeeld de variabele word—werkt zich een weg door de lijst met gegevensitems totdat het het einde van de lijst bereikt. De lustekst geeft toegang tot de waarde in de word variabele en dus wordt elk woord in de lijst verwerkt.
voor lussen met nummerbereiken
Als je een for loop om 100 keer te lopen, het zou een behoorlijk vermoeiende aangelegenheid zijn om een reeks van 100 nummers in de loop-header te moeten typen. Met nummerbereiken kunt u alleen het eerste en laatste nummer opgeven.
Dit script is “number-range.sh.”
#!/bin/bash
for i in {1..10}
do
echo "Loop spin:" $i
done
Het nummerbereik wordt gedefinieerd tussen accolades “{}” met twee perioden “..” het scheiden van de cijfers die het bereik beginnen en beëindigen. Zorg ervoor dat u geen spaties opneemt in de bereikdefinitie.
Dit is hoe het loopt:
./number-range.sh
U kunt een ander nummer opnemen dat de stapgrootte definieert die de iterator moet gebruiken om door de nummers in het bereik te lopen. Dit script, “number-range2.sh” gebruikt een bereik van 0 tot 32 en een stapgrootte van 4.
#!/bin/bash
for i in {0..32..4}
do
echo "Loop spin:" $i
done
De iterator doorloopt het nummerbereik in sprongen van vier.
./number-range2.sh
voor lussen met bestandsnamen
Omdat we lijsten met woorden kunnen verwerken, kunnen we onze scripts laten werken met bestandsnamen. Dit script wordt “bestandsnamen.sh” genoemd.
#!/bin/bash for file in word-list.sh number-range.sh number-range2.sh filenames.sh do ls -lh "$file" done
Het zou vrij zinloos zijn om een script te hebben dat alleen doet wat ls kan doen, maar het laat wel zien hoe u toegang krijgt tot bestandsnamen in de loop-body.
./filenames.sh
Op een vergelijkbare manier als het gebruik van het nummerbereik, kunnen we een bestandspatroon in de luskop gebruiken om de bestanden op te geven die we willen verwerken. Dit voorkomt veel typen en betekent dat we niet van tevoren de namen van de bestanden hoeven te weten.
Dit script wordt “filenames2.sh” genoemd. We hebben de lijst met bestandsnamen vervangen door het bestandsnaampatroon “*.sh” zodat het script rapporteert over alle scriptbestanden in de huidige map.
#!/bin/bash for file in *.sh do ls -lh "$file" done
Hier is de uitvoer.
./filenames2.sh
voor lussen met behulp van opdrachtregelparameters
We kunnen wat meer flexibiliteit toevoegen door het bestandsnaampatroon op de opdrachtregel door te geven. De $* variabele staat voor alle opdrachtregelparameters die aan het script zijn doorgegeven.
Dit is “bestandsnamen3.sh.”
#!/bin/bash for file in $* do ls -lh "$file" done
We vragen om bestandsnamen die beginnen met “n” en een SH-extensie hebben.
./filenames3.sh n*.sh
We kunnen ook meer dan één patroon tegelijk doorgeven.
./filenames3.sh n*.sh .bashrc
De iteratorvariabele file neemt de waarde van elk van de opdrachtregelparameters aan. Bestandsnaampatronen worden uitgebreid en alle bestandsnamen worden verwerkt in de loop-body.
C-achtig voor Loops
Bash ondersteunt de klassieke for-lus met drie termen, zoals die gevonden worden in de programmeertaal C. Ze worden drie-term voor lussen genoemd omdat er drie termen in de luskop staan.
- De beginwaarde van de lus-iterator.
- De test of de lus doorgaat of eindigt.
- Het verhogen of verlagen van de iterator.
Dit script is “c-like.sh.”
de iterator I is ingesteld op 1 aan het begin van de lus, en de lus loopt zo lang als de instructie ” i<=10 ” is waar. Zodra i bereikt 11, de for lus stopt. De iterator wordt met één verhoogd, elke omwenteling van de lus.
#!/bin/bash for (( i=1; i<=10; i++ )) do echo "Loop number:" $i done
Laten we dit script uitvoeren.
./c-like.sh
De C-achtige for lus maakt het eenvoudig maken van for loops die enigszins vreemde vereisten hebben. Deze lus begint bij 15 en telt terug in stappen van 3. Dit is “c-like2.sh”
#!/bin/bash for (( i=15; i>0; i-=3 )) do echo "Loop number:" $i done
Wanneer we het uitvoeren, moet het achteruit springen in stappen van drie.
./c-like2.sh
Oneindig voor lussen
U kunt ook dit formaat van gebruiken for lus om een oneindige lus te maken. Het enige wat u hoeft te doen is alle elementen uit de loop-header te verwijderen, zoals deze. Dit is “oneindig.sh.”
#!/bin/bash for (( ; ; )) do echo "Press Ctrl+C to stop..." sleep 1 done
U moet op Ctrl+C drukken om de lus te stoppen.
./infinite.sh
for Loops met behulp van woordmatrices
We kunnen gemakkelijk een reeks woorden doorlopen. We moeten de naam van de array in de loop-header opgeven en de iterator loopt door alle items in de array. Dit is “word-array.sh.”
#!/bin/bash
distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")
for distro in $distributions
do
echo $distro
done
Alle distributies staan voor ons op een rij.
./word-array.sh
De opdracht doorgaan
Als u wilt dat de lus over een bepaald item stapt, test u of de iterator overeenkomt met dat item en gebruikt u de continue opdracht. De continue commando verlaat de huidig draaien van de lus. Het verhoogt de iterator en start de volgende spin van de lus – ervan uitgaande dat het item dat u wilt overslaan niet het laatste item in de lijst is.
Dit is “word-array2.sh.” Het stapt over het array-item “Arch” maar verwerkt alle andere arrayleden.
#!/bin/bash
distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")
for distro in $distributions
do
if [[ "$distro" == "Arch" ]] ;
then
continue
fi
echo $distro
done
“Arch” verschijnt niet in het terminalvenster.
./word-array2.sh
Het pauze-commando
De break commando breekt uit de lus en voorkomt verdere verwerking.
Dit is “word-array3.sh.” Het is hetzelfde als het vorige script met continue vervangen door break.
#!/bin/bash
distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")
for distro in $distributions
do
if [[ "$distro" == "Arch" ]] ;
then
break
fi
echo $distro
done
Wanneer de iterator “Arch” bevat, stopt de for-lus met verdere verwerking.
./word-array3.sh
voor lussen met associatieve arrays
In Bash 4 en hoger kun je met associatieve arrays lijsten maken met sleutel-waardeparen die kunnen worden doorzocht op sleutel of op waarde. Vanwege de tweerichtingsrelatie tussen de sleutel en de waarde, worden ze ook wel gegevenswoordenboeken genoemd.
We kunnen itereren door een associatieve array met a for lus. Dit script is “associative.sh.” Het definieert een associatieve array met vier items erin, één voor elk van “hond”, “kat”, “robin” en “mens”. Dit zijn de sleutels. De waarden zijn het (standaard) aantal poten die ze elk hebben.
#!/bin/bash
declare -A animals=( [dog]=Four-legged [cat]=Four-legged [robin]=Two-legged [human]=Two-legged )
for legs in ${!animals[@]}
do
if [ ${animals[$legs]} == "Two-legged" ]; then
echo ${legs}
fi
done
De iterator heet legs . Merk op dat de loop-header een “!” uitroepteken. Dit fungeert niet als de logische NOT-operator, het maakt deel uit van de associatieve arraysyntaxis. Het is vereist om door de array te zoeken.
De body van de lus voert een stringvergelijkingstest uit. Als de waarde van het arraylid “Tweebenig” is, drukt het de sleutelwaarde af naar het terminalvenster. Als we het uitvoeren, drukt het script de tweebenige wezens af.
./associative.sh
Itereren over de uitvoer van opdrachten
Als je een commando of een reeks commando’s hebt die een lijst van iets produceren, zoals bestandsnamen, kun je ze doorlopen met een for lus. Je moet oppassen voor onverwachte bestandsnaamuitbreidingen, maar in eenvoudige gevallen is het prima.
Dit script is “command.sh.” het gebruikt ls en wc om een gesorteerde lijst met namen van scriptbestanden te bieden, samen met hun aantal regels, woorden en bytes.
#!/bin/bash for i in $(ls *.sh | sort); do echo $(wc $i) done
Wanneer we het uitvoeren, krijgen we de statistieken voor elk bestand, met de bestanden in alfabetische volgorde.
./command.sh
The Dazzling for Loop
De for loop is een veelzijdige en gemakkelijk te begrijpen scripttool. Maar hoe flexibel het ook is, vergeet niet dat andere lussen niet voor niets bestaan. Laat u niet verblinden door te denken dat de for loop is alles wat je ooit nodig zult hebben.
De while lus is bijvoorbeeld veel beter geschikt voor bepaalde dingen dan de for lus, zoals het lezen van regels uit een bestand.
Het schrijven van goede scripts betekent het gebruik van de meest geschikte tool voor de taak die voorhanden is. De for loop is een geweldig hulpmiddel om in je gereedschapskist met trucs te hebben.