Bash-scripting – While Loop
A herhalingslus is een instructie die een codeblok herhaalt totdat de opgegeven voorwaarde wordt geëvalueerd als onwaar. We kunnen deze verklaring of lus in ons programma gebruiken als we niet weten hoe vaak de voorwaarde eerst als waar zal evalueren voordat de voorwaarde als onwaar wordt geëvalueerd.
Inhoudsopgave
- De syntaxis van een while-lus in BASH Scripting
- Voorbeeld van een lus met while-instructie in Linux
- Een bestand lezen met een while-lus
- Oneindige while-lus
- While-lus om een vast aantal keren te herhalen
- Lees het opdrachtregelargument met getopts-opties
- C-stijl while-lus
- While-lus om bewerkingen op een bestand uit te voeren
- Schrijven naar een bestand met behulp van een while-lus
- Breek en ga door met gebruiken while Loop
- Veelgestelde vragen
De syntaxis van een while-lus in BASH Scripting
while [ condition ]; do # statements # commands done
Als de voorwaarde waar is, worden de opdrachten binnen het while-blok uitgevoerd en opnieuw herhaald nadat de voorwaarde is gecontroleerd. Ook als de voorwaarde onwaar is, worden de instructies binnen het while-blok overgeslagen en worden de instructies na het while-blok uitgevoerd.
Voorbeeld van een lus met while-instructie in Linux
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
een=7
terwijl [ $a -gt 4 ];
Doen
echo $a
((A-))
klaar
echo Uit de lus
Uitleg:
-
#!/usr/bin/bash>: Deze regel wordt a shebang genoemd en geeft het pad aan naar de tolk die moet worden gebruikt om het script uit te voeren. In dit geval specificeert het dat de Bash-shell moet worden gebruikt. -
a=7>: Initialiseert een variabele met de naama>met de waarde 7. -
while [ $a -gt 4 ];>: Start een while-lus die doorgaat zolang de waarde vana>groter is dan 4. -
do>: Markeert het begin van het codeblok dat moet worden uitgevoerd binnen de while-lus. -
echo $a>: Drukt de huidige waarde van de variabele afa>naar de console. -
((a--))>: Verlaagt de waarde vana>door 1. Dit is een verkorte schrijfwijzea=$((a - 1))>. -
done>: Markeert het einde van het codeblok voor de while-lus. -
echo 'Out of the loop'>: wordt vanuit de lus afgedrukt op de console nadat de while-lus is voltooid.
Terwijl Loop in Linux
Samenvattend initialiseert dit script een variabele ` a`> met de waarde 7, en komt vervolgens in een while-lus die doorgaat zolang ` a`> is groter dan 4. Binnen de lus wordt de huidige waarde van ` afgedrukt a`> en verlaagt deze met 1 in elke iteratie. Een keer ` a`> wordt 4 of minder, de lus wordt afgesloten en het script wordt uit de lus afgedrukt naar de console.
Een bestand lezen met een while-lus
We kunnen een bestand met een while-lus in BASH lezen. Door bepaalde parameters te parseren naar de while-lusvoorwaarde, kunnen we het bestand regel voor regel herhalen of voor andere groepen, zoals tekens of woorden.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
bestand=temp.txt
terwijl je -r regel leest;
Doen
echo $regel
klaar <$bestand
Uitleg:
-
#!/usr/bin/bash>: Deze regel geeft aan dat de Bash-shell moet worden gebruikt om het script te interpreteren. -
file=temp.txt>: Wijst de tekenreeks temp.txt toe aan de variabelefile>, die de naam vertegenwoordigt van het bestand dat moet worden gelezen. -
while read -r line;>: Start een while-lus die elke regel uit het opgegeven bestand leest. -
do>: Markeert het begin van het codeblok dat moet worden uitgevoerd binnen de while-lus. -
echo $line>: drukt de inhoud van de variabele afline>, wat de huidige regel vertegenwoordigt die uit het bestand wordt gelezen, naar de console. -
done>: Markeert het einde van het codeblok voor de while-lus. -
<'$file'>: Leidt de invoer van de while-lus om zodat deze uit het opgegeven bestand komt, in dit geval temp.txt.
Samenvattend leest dit script elke regel uit het bestand temp.txt en drukt deze af naar de console totdat er geen regels meer over zijn in het bestand. De -r> optie met de read> De opdracht wordt gebruikt om ervoor te zorgen dat backslashes in de invoer als letterlijke tekens worden behandeld.
lees het bestand met de while-instructie in Linux
We gebruiken de opdracht read om de regels of tekens daadwerkelijk uit het bestand op te halen. Het leescommando wordt doorgegeven met het argument -r, dat het ontsnappen van tekens negeert als de verschijnt en daarom wordt geparseerd als zijn. We lezen een regel uit een bestand dat na de voltooide instructie wordt genoemd. Het leescommando leest een regel uit het genoemde bestand en de while-lussen eindigen wanneer de laatste regel uit het bestand wordt gelezen (er is geen regel meer om te lezen).
Dit is hoe we de inhoud van het bestand kunnen lezen met behulp van een while-lus in BASH.
Oneindige while-lus
Een oneindige lus maken met behulp van een while-lusinstructie. We hoeven geen enkele voorwaarde in de while-lus te plaatsen en daarom herhaalt de lus zich oneindig. Hieronder ziet u een voorbeeld van een oneindige while-lus:
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
terwijl :
Doen
echo Een oneindige lus
# We kunnen op Ctrl + C drukken om het script af te sluiten
klaar
Uitleg:
-
#!/usr/bin/bash>: De shebang-regel geeft aan dat de Bash-shell moet worden gebruikt om het script te interpreteren. -
while :>: Start een oneindige lus. De:>(colon) is een in de shell ingebouwde opdracht die altijd true retourneert, waardoor in feite een oneindige lus ontstaat. -
do>: Markeert het begin van het codeblok dat moet worden uitgevoerd binnen de oneindige lus. -
echo 'An Infinite loop'>: Drukt de string Een oneindige lus af naar de console in elke iteratie van de lus. -
# We can press Ctrl + C to exit the script>: Dit is een opmerking die aangeeft dat u het script kunt onderbreken door in de terminal op Ctrl + C te drukken. Ctrl + C is een gebruikelijke manier om actieve scripts in de terminal te onderbreken en te beëindigen. -
done>: markeert het einde van het codeblok voor de oneindige lus.
Samenvattend creëert dit script een oneindige lus die voortdurend het bericht Een oneindige lus naar de console weergeeft. De lus kan worden onderbroken en het script kan worden afgesloten door in de terminal op Ctrl + C te drukken.
Oneindige lus met behulp van While-instructie in Linux
De while-lus in het script zal dus oneindig lang herhalen. We kunnen de lus of het script handmatig verbreken door CTRL + C.
While-lus om een vast aantal keren te herhalen
We kunnen een while-lus gebruiken om een vast aantal keren te herhalen, we kunnen de voorwaarde instellen op -le of kleiner dan gelijk aan een getal, en de lus zal herhalen totdat de iterator kleiner is dan of gelijk is aan het getal dat is opgegeven in de conditie. We moeten de iterator ook handmatig verhogen, zodat de lus-iterator blijft tikken, anders blijft de lus voor altijd doorgaan.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
ik=1
# het getal 4 kan de limiet zijn
# herhaal de lus
terwijl [ $i -le 4 ];
Doen
echo $i
((ik++))
klaar
Uitleg:
-
#!/usr/bin/bash>: De shebang-regel geeft aan dat de Bash-shell moet worden gebruikt om het script te interpreteren. -
i=1>: Initialiseert een variabele met de naami>met de waarde 1. -
while [ $i -le 4 ];>: Start een while-lus die doorgaat zolang de waarde vani>is kleiner dan of gelijk aan 4. -
do>: Markeert het begin van het codeblok dat moet worden uitgevoerd binnen de while-lus. -
echo $i>: Drukt de huidige waarde van de variabele afi>naar de console. -
((i++))>: Verhoogt de waarde vani>door 1. Dit is een verkorte schrijfwijzei=$((i + 1))>. -
done>: Markeert het einde van het codeblok voor de while-lus.
while-lus in Linux
In het bovenstaande voorbeeld kunnen we zien dat de lus een bepaald aantal keren itereert. Omdat we de teller op 1 hebben geïnitialiseerd en de voorwaarde is om de lus te herhalen totdat de iterator kleiner is dan of gelijk is aan het getal in dit geval 4. We kunnen dus het getal in de voorwaarde wijzigen volgens onze vereisten.
Lees het opdrachtregelargument met getopts-opties
We kunnen get ops-opties gebruiken om de invoer van de opdrachtregel te lezen en als er meerdere argumenten zijn, kunnen we ze controleren en één voor één ontleden met behulp van een while-lus. getopts is een hulpmiddel om gebruikersinvoer vanaf de opdrachtregel te krijgen. We kunnen meerdere opties hebben om vanaf de opdrachtregel te parseren, en met behulp van getopts en while-lussen kunnen we een professioneel ogend gebruikersinvoerprogramma maken.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/bin/bash
terwijl getopts n:a: OPT
Doen
geval ${OPT} in
n) naam=${OPTARG} ;;
a) leeftijd=${OPTARG} ;;
*) echo Ongeldige optie
uitgang 1;;
esac
klaar
printf Mijn naam is $name en ik ben $leeftijd jaar oud
Uitleg:
-
#!/bin/bash>: De shebang-regel geeft aan dat de Bash-shell moet worden gebruikt om het script te interpreteren. -
while getopts n:a: OPT>: Start een lus die gebruikmaakt vangetopts>om opdrachtregelopties te parseren. De opgegeven opties zijnn>Ena>, die naar verwachting beide zullen worden gevolgd door een argument. -
do>: Markeert het begin van het codeblok dat binnen de lus moet worden uitgevoerd. -
case '${OPT}' in>: Start een case-instructie die de waarde evalueert van de optie die u tegenkomtgetopts>. -
n) name=${OPTARG};;>: Als de optie is-n>, wijst de waarde van het overeenkomstige argument toe aan de variabelename>. -
a) age=${OPTARG};;>: Als de optie is-a>, wijst de waarde van het overeenkomstige argument toe aan de variabeleage>. -
*) echo 'Invalid option'>: Als er een ongeldige optie wordt aangetroffen, wordt er een foutmelding naar de console afgedrukt. -
exit 1;;>: Sluit het script af met een statuscode die niet nul is, wat een fout aangeeft. -
esac>: Beëindigt de case-instructie. -
done>: markeert het einde van het codeblok voor de lus. -
printf 'My name is $name and am $age years old '>: Drukt een opgemaakt bericht af naar de console met de waarden van `name`>en `age`>verkregen via de opdrachtregelopties.
While-lus in Linux
In dit geval hebben we twee opties, namelijk de naam en de leeftijd. U kunt meerdere opties hebben. We moeten specificeren welke optie we gaan gebruiken via de switch case-instructies en vanaf de opdrachtregel met de optie -shorthand. In dit geval hebben we gebruik gemaakt van -n voor naam En -a voor leeftijd . We hebben ook een standaard- of ongeldige case-check om te voorkomen dat we verkeerde argumenten ontleden. We kunnen de waarde van de optie toewijzen met behulp van de OPTARG variabele die de waarde parseert die aan de optie is gegeven.
De while-lus wordt hier gebruikt om te herhalen totdat er geen opties meer worden doorgegeven vanaf de opdrachtregel. We controleren op de opties -n en -a en herhalen totdat de Enter-toets of de Enter-toets wordt ingedrukt en er geen verdere opties meer zijn om te parseren.
C-stijl while-lus
We kunnen de while-lus in C-stijl gebruiken in BASH, de variabelen moeten worden geëvalueerd met de BASH-stijl, maar de algemene syntaxis voelt aan als C. We kunnen operatoren zoals , <= enzovoort gebruiken in de toestand van de while-lus en vandaar wordt genoemd als de C-stijl while-lus.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim c-style-while.sh
#!/bin/bash
ik=0
terwijl ((ik <12))
Doen
echo $i
((ik+=2))
klaar
c-stijl-terwijl
In dit voorbeeld kunnen we zien dat de while-lus een voorwaarde heeft met niet-bash-operatoren zoals -le, -ge, enz. In plaats daarvan gebruiken we de C-stijl operators in de voorwaarde. De rest van de lus is de basislus zoals in BASH, de variabele of iterator i wordt met twee verhoogd, zoals we kunnen zien in de laatste instructie van de lusbody. De lus herhaalt zich dus meer dan 5 keer.
While-lus om bewerkingen op een bestand uit te voeren
We kunnen bewerkingen op een bestand uitvoeren, zoals het lezen van slechts een bepaald deel van een bestand. Als we kolommen hebben die op een bepaalde manier zijn opgemaakt, kunnen we variabelen gebruiken om ze toe te wijzen en ze per rijgegevens af te drukken.
Hier is de voorbeeldbestandsnaam wh.txt
vim wh.txt
we maken een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim file-while.sh
Taaltype vrijgegeven
Python-generaal 1991
JavaScript-web 1995
Java mobiel 1995
Roest ingebed 2010
Ga naar backend 2007
we maken een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim file-while.sh
#!/bin/bash
terwijl je a b c leest
Doen
echo $b – $a
klaar
While-lus in Linux
In dit voorbeeld hebben we drie rijen, we lezen de inhoud door ze toe te wijzen aan de variabelen a,b en c. Het kan van alles zijn wat je maar wilt, maar vergeet niet om ze in de hoofdtekst van de lus te gebruiken. We kunnen een bepaalde kolom zoals b en a selecteren en er bewerkingen op uitvoeren of afdrukken. Dit wordt echter niet weerspiegeld in het bestand, omdat het slechts de lokale scriptvariabelen zijn.
Schrijven naar een bestand met behulp van een while-lus
We kunnen naar een bestand schrijven door gebruikersinvoer in een while-lus. We kunnen de while-lus gebruiken om te herhalen totdat we de lus handmatig verlaten met behulp van CTRL + D door wijzigingen in het bestand op te slaan of met CTRL + C om te voorkomen dat naar het bestand wordt geschreven. We gebruiken de opdracht read om de tekst vanaf de opdrachtregel in te voeren en deze in het bestand te parseren.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim write-wh.sh
#! /bin/bash
bestand=wh.txt
echo Voer de inhoud in het bestand $file in
terwijl u de regel leest
Doen
echo $regel>> $bestand
klaar
while-lus in Linux
Dus uit het bovenstaande voorbeeld konden we tekst in een bestand invoeren met behulp van een while-lus en leesopdracht. Om de lus te verlaten en wijzigingen in het bestand op te slaan, gebruiken we de CTRL+D-toetsen, en om de lus te verlaten zonder iets in het bestand op te slaan, kunnen we de CTRL + C-toetsen gebruiken. We voeren dus de tekst van de opdrachtregel in het tekstbestand in met behulp van het leescommando en een while-lus.
Breek en ga door met gebruiken while Loop
Onderbreken en doorgaan zijn essentieel in een programma dat zich bezighoudt met lusinstructies, omdat ze de stroom van de lusinstructies controleren zonder enige expliciete voorwaarden.
Break-instructie in While Loop
We gebruiken break-instructies om de lus te verlaten zonder te wachten tot de voorwaarde van de while-lus is geëvalueerd als false. Deze instructie kan binnen een lusblok worden gebruikt. Dit kan worden gebruikt om een oneindige lus te verlaten met een programmatische voorwaarde binnen de lus en zo de controle over de lus te behouden.
We hebben bijvoorbeeld een script dat telt van 1 tot voor altijd. Maar we kunnen programmatisch uit de lus breken met behulp van een break-instructie in de hoofdtekst van de lus met een voorwaarde.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
ik=1
terwijl :
Doen
echo $i
als [ $i -eq 20 ]; Dan
echo Dit is het einde van de lus
pauze
zijn
((ik++))
klaar
Break-instructie while-lus in Linux
Uit het script en de uitvoering kunnen we zien dat we een oneindige lus konden verbreken of beëindigen met een voorwaardelijke instructie en de break-instructie. De instructie break wordt dus gebruikt om de besturingsstroom van een programma/script vanuit een while-lus uit de lus te laten breken zonder dat de lusvoorwaarde als false wordt geëvalueerd.
Ga door met de instructie in While Loop
We kunnen de continue-instructie gebruiken om het tegenovergestelde van de break-instructie te doen. Het springt naar het begin van het lusblok en herhaalt het opnieuw. Dit kan worden gebruikt om onder bepaalde omstandigheden bepaalde opdrachten over te slaan, waardoor een verandering in de loop van de lus mogelijk is.
Als we bijvoorbeeld een variabele hebben die is geïnitialiseerd op 1 en we alleen de getallen willen weergeven die deelbaar zijn door vijf of in een bepaald patroon na een voorwaarde, kunnen we continue-instructies gebruiken om precies dat te doen. Dit maakt iteratie over de lus op de gewenste manier mogelijk.
Eerst maken we een tekstbestand met behulp van een teksteditor in Linux, in dit geval gebruiken we de `vim` Teksteditor.
vim while.sh
#!/usr/bin/bash
ik=1
terwijl [ $i -lt 30 ];
Doen
((ik++))
als [[ $(( $i % 5 )) -ne 0 ]];
Dan
doorgaan
zijn
echo $i
klaar
Ga door met de instructie in While-lus in Linux
Zoals we kunnen zien, springt de continue-instructie naar het begin van het blok en start de uitvoering van de opdrachten door de volgende opdrachten binnen het blok over te slaan. De while-lus herhaalt zich alleen voor de waarde van variabele ik kleiner zijn dan 30, dus de if-voorwaarde controleert of de variabele ik is deelbaar door 5, en als dit niet het geval is, herhalen we het opnieuw met behulp van continue en verhogen we de waarde van de variabele i. De variabele ik Er wordt alleen een echo gemaakt als deze deelbaar is door 5, dus de if-voorwaarde wordt geëvalueerd als false en we komen geen continue-instructie tegen die meegaat met de normale stroom van de lus. Dit wordt gedaan om te voorkomen dat elk getal wordt geregistreerd en alleen de getallen worden afgedrukt die geen patroon of voorwaarde volgen in de if-instructie of andere voorwaardelijke instructies.
Veelgestelde vragen
1. Wat is een ` while`> lus in Bash-scripting?
A while> loop is een control flow-instructie in Bash-scripting waarmee een bepaald codeblok herhaaldelijk kan worden uitgevoerd zolang een opgegeven voorwaarde waar is. De lus biedt een manier om repetitieve taken te automatiseren en is een fundamentele constructie bij scripting en programmeren.
2. Hoe werkt de syntaxis van een ` while`> lus kijken in Bash?
De basissyntaxis van a while> lus in Bash is als volgt:
terwijl [voorwaarde]
Doen
# Code die moet worden uitgevoerd terwijl de voorwaarde waar is
klaar
De ` condition`> is een test die plaatsvindt vóór elke iteratie van de lus. Als de voorwaarde waar is, wordt de code in de lus uitgevoerd. Als de voorwaarde onwaar is, wordt de lus afgesloten en gaat het script verder met de volgende opdracht na de ` done`> stelling.
3. Wat is de rol van de ` (( ... ))`> bouwen in een Bash while> lus?
De ` (( ... ))`> construct in Bash wordt gebruikt voor rekenkundige bewerkingen. In de context van een ` while`> lus, wordt het vaak gebruikt om rekenkundige voorwaarden te evalueren.
Bijvoorbeeld: ` ((i <10))> `> controleert of de variabele ` i`> is kleiner dan 10. Hierdoor kunt u rekenkundige uitdrukkingen rechtstreeks in de lusvoorwaarde gebruiken, wat dit vooral handig maakt bij numerieke vergelijkingen.
4. Hoe je een oneindige lus maakt met ` while`> in bash?
Er kan een oneindige lus in Bash worden gemaakt door een voorwaarde op te geven die altijd als waar resulteert.
Bijvoorbeeld:
terwijl het waar is
Doen
# Code voor de oneindige lus
klaar
Als alternatief kunt u een constante die niet nul is in de voorwaarde gebruiken, bijvoorbeeld ` while [ 1 ]`> , om hetzelfde resultaat te bereiken. Oneindige lussen zijn handig in situaties waarin continue uitvoering vereist is totdat deze handmatig wordt onderbroken.
Conclusie
In dit artikel hebben we de BASH-scripting while-lus besproken, die een veelzijdig hulpmiddel blijkt te zijn voor het herhaaldelijk uitvoeren van een codeblok op basis van een gespecificeerde voorwaarde. De basissyntaxis omvat het definiëren van de voorwaarde tussen vierkante haakjes, waardoor flexibele iteraties mogelijk zijn. In het artikel worden diverse toepassingen van while-lussen onderzocht, waaronder het lezen uit bestanden, het maken van oneindige lussen, vaste iteraties, het ontleden van opdrachtregelargumenten en het gebruik van break- en continue-instructies. Van syntaxis in C-stijl tot interactief schrijven van bestanden, elk voorbeeld demonstreert het aanpassingsvermogen van de lus bij het aanpakken van een reeks scriptbehoeften. Dit uitgebreide overzicht onderstreept het belang van de while-lus in BASH-scripting en biedt een robuust mechanisme voor gecontroleerde herhaling en efficiënte code-uitvoering.
