Alles wat u moet weten over Bash For Loops in Linux

Bash-scripts zijn een zeer efficiënt middel om taken te automatiseren, met name die welke gebruikmaken van andere bestaande programma's. Deze automatisering vereist vaak het meerdere keren herhalen van een soortgelijke handeling, en dat is precies waar de for loop komt tot zijn recht.

Linux- en Mac-systeembeheerders zijn doorgaans bekend met scripting via de terminal, maar zelfs Windows-gebruikers kunnen dit kom in actie met het Windows-subsysteem voor Linux .

Hoe Bash-scripts werken

Een bash-script is gewoon een tekstbestand zonder opmaak dat een reeks opdrachten bevat die de bash-shell kan lezen en uitvoeren. Bash is de standaardshell in pre-Catalina macOS en de meeste Linux-distributies.

Als je nog nooit met een shellscript hebt gewerkt, moet je beginnen met het absoluut eenvoudigste geval. Hiermee kunt u de belangrijkste concepten oefenen, waaronder het maken van het script en de uitvoering ervan.

Maak eerst het volgende bestand op een handige locatie (idealiter opent u een terminal en navigeert u eerst naar de gewenste map):

#!/bin/bash  
echo 'Hello, World'

De eerste regel vertelt wat dit programma ook draait, hoe het moet worden uitgevoerd (d.w.z. met behulp van de bash-interpreter). De tweede is gewoon een opdracht zoals elke andere die u op de opdrachtregel zou kunnen invoeren. Sla dat bestand op als hallo_world.sh , dan:

$ chmod +x hello_world.sh  
$ ./hello_world.sh

De chmod commando op de eerste regel maakt het bestand uitvoerbaar, wat betekent dat het kan worden uitgevoerd door de naam te typen, zoals in de tweede regel.

Als u de woorden Hallo, Wereld op een regel in uw terminal ziet verschijnen, werkt alles zoals vereist.

Hoe voor lussen werken

Bij algemene programmering zijn er twee hoofdtypen for-lus: numeriek en foreach . Het numerieke type is traditioneel de meest voorkomende, maar bij bash-gebruik is het meestal andersom.

Numerieke for-lussen richten zich meestal op een enkel geheel getal dat bepaalt hoeveel iteraties zullen worden uitgevoerd, bijvoorbeeld:

for (i = 0; i <100; i++) {  
 /* statements to execute repeatedly */  
}

Dit is een bekende for-lus die exact 100 keer zal herhalen, tenzij i binnen de lus wordt gewijzigd, of een andere instructie ervoor zorgt dat de uitvoering van de for-lus stopt.

Foreach-lussen daarentegen werken meestal op structuren zoals lijsten of arrays en herhalen voor elk item binnen die verzameling:

people = [ 'Peter', 'Paul', 'Mary' ]  
foreach (people as person) {  
 if (person == 'Paul') {  
 ...  
 }  
}

Sommige talen gebruiken een iets andere syntaxis die de volgorde van verzameling en item omwisselt:

people = [ 'Peter', 'Paul', 'Mary' ]  
for (person in people) {  
 if (person == 'Paul') {  
 ...  
 }  
}

Voor in Loops

In bash, de foreach-of voor in -lus komt vaker voor. De basissyntaxis is eenvoudig:

for arg in [list]  
do  
 /* statements to execute repeatedly */  
 /* the value of arg can be obtained using $arg */  
done

Om bijvoorbeeld drie bestanden met een expliciete naam te doorlopen:

Windows 10 eruit laten zien als xp

for file in one.c two.c three.c  
do  
 ls '$file'  
done

Als dergelijke bestanden in de huidige map bestaan, is de uitvoer van dit script:

one.c  
two.c  
three.c

In plaats van een vaste set bestanden, kan de lijst worden verkregen via een glob-patroon (een inclusief jokertekens - speciale tekens die andere tekens vertegenwoordigen). In het volgende voorbeeld herhaalt de for-lus alle bestanden (in de huidige map) waarvan de naam eindigt op '.xml':

for file in *.xml  
do  
 ls -l '$file'  
done

Hier is een voorbeelduitvoer:

$ -rw-r--r-- 1 bobby staff 2436 3 Nov 2019 feed.xml  
$ -rw-r--r-- 1 bobby staff 6447 27 Oct 16:24 sitemap.xml

Dit lijkt misschien erg op een omslachtige manier van doen:

$ ls -l *.xml

Maar er is een significant verschil: de for-lus voert de . uit ls programma 2 afzonderlijke tijden, met elke keer een enkele bestandsnaam. In het afzonderlijke ls-voorbeeld komt het glob-patroon (*.xml) eerst overeen met de bestandsnamen en stuurt deze vervolgens allemaal, als individuele opdrachtregelparameters, naar één instantie van ls .

Hier is een voorbeeld dat de . gebruikt wc (woorden tellen) programma om het verschil duidelijker te maken:

$ wc -l *.xml  
44 feed.xml  
231 sitemap.xml  
275 total

De wc programma telt het aantal regels in elk bestand afzonderlijk en drukt vervolgens een totale telling over alle regels af. In tegenstelling, als wc werkt binnen een for-lus:

for file in *.xml  
do  
 wc -l $file  
done

Je ziet nog steeds het aantal voor elk bestand:

44 feed.xml  
231 sitemap.xml

Maar er is geen algemeen totaaloverzicht omdat: wc wordt geïsoleerd uitgevoerd, elke keer dat de lus wordt herhaald.

Wanneer een lijst geen lijst is

Er is een heel gemakkelijke en veelgemaakte fout bij het omgaan met for-lussen, vanwege de manier waarop bash omgaat met geciteerde argumenten/strings. Het doorlopen van een lijst met bestanden moet als volgt gebeuren:

for file in one.c two.c

Niet zoals dit:

for file in 'one.c two.c'

Het tweede voorbeeld plaatst bestandsnamen tussen dubbele aanhalingstekens, wat resulteert in een lijst met slechts een enkele parameter; de for-lus wordt maar één keer uitgevoerd. Dit probleem kan worden vermeden door in dergelijke gevallen een variabele te gebruiken:

FILES='one.c two.c'  
for file in $FILES  
do  
 ...  
done

Merk op dat de variabeledeclaratie zelf zijn waarde tussen dubbele aanhalingstekens moet zetten!

wat voor plant is dit?

Voor zonder lijst

Met niets om door te itereren, werkt een for-lus op alle opdrachtregelargumenten die aan het script werden verstrekt toen het werd aangeroepen. Als u bijvoorbeeld een script heeft met de naam args.sh met daarin het volgende:

#!/bin/sh  
for a  
do  
 echo $a  
done

Als u vervolgens args.sh uitvoert, krijgt u het volgende:

$ ./args.sh one two three  
one  
two  
three

Bash herkent deze zaak en behandelt voor een do als het equivalent van voor een in $@ do waarbij $@ een speciale variabele is die opdrachtregelargumenten vertegenwoordigt.

Een traditionele numerieke for-lus emuleren

Bash-scripts hebben vaak te maken met lijsten met bestanden of uitvoerregels van andere commando's, dus het for in-type lus is gebruikelijk. De traditionele bewerking in c-stijl wordt echter nog steeds ondersteund:

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

Dit is de klassieke vorm met drie delen waarin:

een variabele wordt geïnitialiseerd (i=1) wanneer de lus voor het eerst wordt aangetroffen
de lus gaat door zolang de voorwaarde (i<=5) is true
elke keer rond de lus wordt de variabele verhoogd (i++)

Itereren tussen twee waarden is een algemene vereiste dat er een korter, iets minder verwarrend alternatief is:

for i in {1..5}  
do  
 echo $i  
done

De brace-expansie die plaatsvindt, vertaalt de bovenstaande for-lus effectief in:

for i in 1 2 3 4

Fijnere luscontrole met pauze en doorgaan

Complexere for-lussen hebben vaak een manier nodig om de hoofdlus vroegtijdig te verlaten of onmiddellijk opnieuw te starten met de volgende waarde op zijn beurt. Om dit te doen, leent bash de break-and-continue-statements die gebruikelijk zijn in andere programmeertalen. Hier is een voorbeeld dat beide gebruikt om het eerste bestand te vinden dat meer dan 100 tekens lang is:

#!/bin/bash  
for file in *  
do  
 if [ ! -f '$file' ]  
 then  
 echo '$file is not a file'  
 continue  
 fi  
 num_chars=$(wc -c <'$file')  
 echo $file is '$num_chars characters long'  
 if [ $num_chars -gt 100 ]  
 then  
 echo 'Found $file'  
 break  
 fi  
done

De for-lus werkt hier op alle bestanden in de huidige map. Als het bestand geen normaal bestand is (bijvoorbeeld als het een map is), wordt de instructie continue gebruikt om de lus opnieuw te starten met het volgende bestand op zijn beurt. Als het een normaal bestand is, bepaalt het tweede voorwaardelijke blok of het meer dan 100 tekens bevat. Als dat het geval is, wordt het break-statement gebruikt om de for-lus onmiddellijk te verlaten (en het einde van het script te bereiken).

Conclusie

Een bash-script is een bestand dat een reeks instructies bevat die kunnen worden uitgevoerd. Met een for-lus kan een deel van een script vele malen worden herhaald. Met het gebruik van variabelen, externe commando's en de break-and-continue-statements, kunnen bash-scripts complexere logica toepassen en een breed scala aan taken uitvoeren.

Deel Deel Tweeten E-mail Is het de moeite waard om te upgraden naar Windows 11?

Windows is opnieuw ontworpen. Maar is dat genoeg om u te overtuigen om over te stappen van Windows 10 naar Windows 11?

Lees volgende Gerelateerde onderwerpen

Programmeren
Linux

Over de auteur Bobby Jack(58 artikelen gepubliceerd)

Bobby is een technologie-enthousiasteling die bijna twee decennia als softwareontwikkelaar heeft gewerkt. Hij is gepassioneerd door gaming, werkt als recensie-editor bij Switch Player Magazine en is ondergedompeld in alle aspecten van online publiceren en webontwikkeling.

Meer van Bobby Jack

Abonneer op onze nieuwsbrief

Word lid van onze nieuwsbrief voor technische tips, recensies, gratis e-boeken en exclusieve deals!

Klik hier om je te abonneren