Bash Scripting – While Loop
A medan loop är en sats som itererar över ett kodblock tills det angivna villkoret utvärderas till falskt. Vi kan använda detta påstående eller loop i vårt program när vi inte vet hur många gånger villkoret kommer att utvärderas till sant innan det utvärderas till falskt.
Innehållsförteckning
- Syntaxen för en while-loop i BASH Scripting
- Looping Exempel med while-sats i Linux
- Läser en fil med en while-loop
- Oändlig while-loop
- Medan loop för att iterera ett bestämt antal gånger
- Läs kommandoradsargumentet med getopts-alternativ
- C-stil medan loop
- While loop för att utföra operationer på en fil
- Skriva till en fil med en while-loop
- Bryt och fortsätt använda medan loop
- Vanliga frågor
Syntaxen för en while-loop i BASH Scripting
while [ condition ]; do # statements # commands done
Om villkoret är sant exekveras kommandona inuti while-blocket och upprepas igen efter kontroll av villkoret. Även om villkoret är falskt hoppas påsatserna i while-blocket över och satserna efter while-blocket exekveras.
Looping Exempel med while-sats i Linux
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
a=7
while [ $a -gt 4 ];
do
eko $a
((a–))
Gjort
eko Ut ur slingan
Förklaring:
-
#!/usr/bin/bash>: Den här raden kallas en shebang och indikerar sökvägen till tolken som ska användas för att köra skriptet. I det här fallet specificerar det att Bash-skalet ska användas. -
a=7>: Initierar en variabel med namneta>med värdet 7. -
while [ $a -gt 4 ];>: Startar en while-loop som fortsätter så länge som värdet påa>är större än 4. -
do>: Markerar början av kodblocket som ska exekveras inom while-loopen. -
echo $a>: Skriver ut det aktuella värdet för variabelna>till konsolen. -
((a--))>: Minskar värdet påa>av 1. Detta är ett förkortat sätt att skrivaa=$((a - 1))>. -
done>: Markerar slutet av kodblocket för while-slingan. -
echo 'Out of the loop'>: Skriver ut ur slingan till konsolen efter att while-slingan har slutförts.
Medan Loop i Linux
Sammanfattningsvis initierar detta skript en variabel ` a`> med värdet 7, går sedan in i en while-loop som fortsätter så länge som ` a`> är större än 4. Inom slingan skriver den ut det aktuella värdet på ` a`> och minskar den med 1 i varje iteration. En gång ` a`> blir 4 eller mindre, slingan avslutas och skriptet skrivs ut ur slingan till konsolen.
Läser en fil med en while-loop
Vi kan läsa en fil med en while-loop i BASH. Genom att analysera vissa parametrar till while-loopvillkoret kan vi iterera över filen rad för rad eller efter andra grupper som tecken eller ord.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
file=temp.txt
medan du läser -r rad;
do
echo $line
klar <$fil
Förklaring:
-
#!/usr/bin/bash>: Den här shebang-raden anger att Bash-skalet ska användas för att tolka skriptet. -
file=temp.txt>: Tilldelar strängen temp.txt till variabelnfile>, representerar namnet på filen som ska läsas. -
while read -r line;>: Initierar en while-loop som läser varje rad från den angivna filen. -
do>: Markerar början av kodblocket som ska exekveras inom while-loopen. -
echo $line>: Skriver ut innehållet i variabelnline>, som representerar den aktuella raden som läses från filen, till konsolen. -
done>: Markerar slutet av kodblocket för while-slingan. -
<'$file'>: Omdirigerar indata från while-loopen så att den kommer från den angivna filen, i det här fallet temp.txt.
Sammanfattningsvis läser detta skript varje rad från filen temp.txt och skriver ut den till konsolen tills det inte finns fler rader kvar i filen. De -r> alternativet med read> kommandot används för att säkerställa att omvänt snedstreck i inmatningen behandlas som bokstavliga tecken.
läs filen med while-satsen i Linux
Vi använder kommandot read för att faktiskt hämta raderna eller tecknen från filen. Read-kommandot skickas med -r-argumentet som ignorerar escape av tecken om visas och därför tolkas det som dess. Vi läser en rad från en fil som nämns efter det färdiga uttalandet. Läskommandot läser en rad från den nämnda filen och while-slingorna slutar när den sista raden från filen läses (ingen rad finns kvar att läsa).
Så här kan vi läsa innehållet i filen med hjälp av en while-loop i BASH.
Oändlig while-loop
För att skapa en oändlig loop med hjälp av en while loop-sats. Vi behöver inte sätta något villkor i while-slingan och därför itererar loopen oändligt. Nedan är exemplet på en infinite while-loop:
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
medan:
do
echo En oändlig loop
# Vi kan trycka på Ctrl + C för att avsluta skriptet
Gjort
Förklaring:
-
#!/usr/bin/bash>: Shebang-raden anger att Bash-skalet ska användas för att tolka skriptet. -
while :>: Initierar en oändlig loop. De:>(kolon) är ett inbyggt skal-kommando som alltid returnerar sant, vilket effektivt skapar en oändlig loop. -
do>: Markerar början av kodblocket som ska exekveras inom den oändliga slingan. -
echo 'An Infinite loop'>: Skriver ut strängen En oändlig loop till konsolen i varje iteration av loopen. -
# We can press Ctrl + C to exit the script>: Detta är en kommentar som indikerar att du kan avbryta skriptet genom att trycka på Ctrl + C i terminalen. Ctrl + C är ett vanligt sätt att avbryta och avsluta körande skript i terminalen. -
done>: Markerar slutet av kodblocket för den oändliga slingan.
Sammanfattningsvis skapar detta skript en oändlig loop som kontinuerligt ekar meddelandet En oändlig loop till konsolen. Slingan kan avbrytas och skriptet avslutas genom att trycka på Ctrl + C i terminalen.
Oändlig loop med While Statement i Linux
Således kommer while-slingan i skriptet att iterera i oändlig tid. Vi kan manuellt bryta slingan eller skriptet med CTRL + C.
Medan loop för att iterera ett bestämt antal gånger
Vi kan använda en while-slinga för att iterera över ett bestämt antal gånger, vi kan ställa in villkoret till att vara -le eller mindre än lika med ett tal, och loopen kommer att iterera tills iteratorn är mindre än eller lika med antalet som anges i skicket. Dessutom måste vi öka iteratorn manuellt för att hålla loop-iteratorn tickande, annars kommer loopen att fortsätta för alltid.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
i=1
# siffran 4 kan vara gränsen till
# upprepa loopen
medan [ $i -le 4 ];
do
eko $i
((i++))
Gjort
Förklaring:
-
#!/usr/bin/bash>: Shebang-raden anger att Bash-skalet ska användas för att tolka skriptet. -
i=1>: Initierar en variabel med namneti>med värdet 1. -
while [ $i -le 4 ];>: Initierar en while-loop som fortsätter så länge som värdet påi>är mindre än eller lika med 4. -
do>: Markerar början av kodblocket som ska exekveras inom while-loopen. -
echo $i>: Skriver ut det aktuella värdet för variabelni>till konsolen. -
((i++))>: Ökar värdet påi>av 1. Detta är ett förkortat sätt att skrivai=$((i + 1))>. -
done>: Markerar slutet av kodblocket för while-slingan.
medan loop i Linux
I exemplet ovan kan vi se att loopen itererar ett definierat antal gånger. Eftersom vi har initierat räknaren till 1 och villkoret är att iterera slingan tills iteratorn är mindre än eller lika med talet i detta fall 4. Således kan vi ändra numret i villkoret enligt våra krav.
Läs kommandoradsargumentet med getopts-alternativ
Vi kan använda get ops-alternativ för att läsa indata från kommandoraden och om det finns flera argument kan vi kontrollera dem och analysera dem en efter en med en while-loop. getopts är ett verktyg för att få användarinmatning från kommandoraden. Vi kan ha flera alternativ för att analysera från kommandoraden, och med hjälp av getopts och while-loopar kan vi skapa ett professionellt utseende användarinmatningsprogram.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/bin/bash
medan getopts n:a: OPT
do
fall ${OPT} in
n) namn=${OPTARG} ;;
a) ålder=${OPTARG} ;;
*) echo Ogiltigt alternativ
utgång 1;;
esac
Gjort
printf Mitt namn är $name och jag är $age år gammal
Förklaring:
-
#!/bin/bash>: Shebang-raden anger att Bash-skalet ska användas för att tolka skriptet. -
while getopts n:a: OPT>: Initierar en loop som användergetopts>för att analysera kommandoradsalternativ. De angivna alternativen ärn>ocha>, som båda förväntas följas av ett argument. -
do>: Markerar början av kodblocket som ska exekveras i slingan. -
case '${OPT}' in>: Startar en case-sats som utvärderar värdet av alternativet som påträffas avgetopts>. -
n) name=${OPTARG};;>: Om alternativet är-n>, tilldelar variabeln värdet på motsvarande argumentname>. -
a) age=${OPTARG};;>: Om alternativet är-a>, tilldelar variabeln värdet på motsvarande argumentage>. -
*) echo 'Invalid option'>: Om ett ogiltigt alternativ påträffas skrivs ett felmeddelande ut till konsolen. -
exit 1;;>: Avslutar skriptet med en statuskod som inte är noll, vilket indikerar ett fel. -
esac>: Avslutar fallbeskrivningen. -
done>: Markerar slutet av kodblocket för slingan. -
printf 'My name is $name and am $age years old '>: Skriver ut ett formaterat meddelande till konsolen med värdena för `name`>och `age`>hämtas från kommandoradsalternativen.
Medan loop i Linux
I det här fallet har vi två alternativ, nämligen namnet och åldern, du kan ha flera alternativ. Vi måste specificera vilket alternativ vi ska använda switch case-satserna och från kommandoraden med -shorthand alternativet. I det här fallet har vi använt -n för namn och -a för ålder . Vi har också en standard eller ogiltiga fallkontroll för att tåla att vi inte analyserar fel argument. Vi kan tilldela värdet på alternativet med hjälp av OPTARG variabel som analyserar värdet som tillhandahålls för alternativet.
While-slingan här används för att iterera tills det inte finns några alternativ som skickas från kommandoraden. Vi letar efter alternativen -n och -a och itererar tills vagnretur- eller enter-tangenten trycks ned och det inte finns några ytterligare alternativ att analysera.
C-stil medan loop
Vi kan använda C-stilad while-loop i BASH, variablerna måste utvärderas med BASH-stil men den övergripande syntaxen känns som C. Vi kan använda operatorerna som , <= och så vidare i tillståndet för while-slingan och därav det kallas som den C-stilade while-loopen.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim c-style-while.sh
#!/bin/bash
i=0
medan ((i <12))
do
eko $i
((i+=2))
Gjort
c-stil medan
I det här exemplet kan vi se att while-loopen har ett villkor med icke-bash-operatorer som -le, -ge, etc. istället använder vi C-stilade operatorer i villkoret. Resten av slingan är den grundläggande slingan som i BASH, variabeln eller iteratorn i inkrementeras med två som vi kan se i den sista satsen i loopkroppen. Således itererar slingan över 5 gånger.
While loop för att utföra operationer på en fil
Vi kan utföra operationer på en fil, som att bara läsa en viss del av en fil. Om vi har kolumner som är formaterade på ett visst sätt, kan vi använda variabler för att tilldela dem och skriva ut dem en rad datatid.
Här är exemplet på filnamnet wh.txt
vim wh.txt
vi skapar en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim file-while.sh
Språktyp släppt
Python general 1991
Javascript webben 1995
Java mobil 1995
Rust inbäddad 2010
Gå backend 2007
vi skapar en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim file-while.sh
#!/bin/bash
medan du läser a b c
do
echo $b – $a
Gjort
Medan loop i Linux
I det här exemplet har vi tre rader, vi läser innehållet genom att tilldela dem variablerna a,b och c, det kan vara vad du vill men kom ihåg att använda dem i loopkroppen. Vi kan välja en viss kolumn som b och a och kan skriva ut eller utföra några operationer på dem. Detta kommer dock inte att återspeglas i filen eftersom de bara är de lokala skriptvariablerna.
Skriva till en fil med en while-loop
Vi kan skriva till en fil genom användarinmatning i en while-loop. Vi kan använda while-loopen för att iterera tills vi manuellt lämnar loopen med CTRL + D genom att spara ändringar i filen eller genom att CTRL + C för att undvika att skriva till filen. Vi använder kommandot read för att mata in texten från kommandoraden och analysera den till filen.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim write-wh.sh
#! /bin/bash
file=wh.txt
echo Ange innehållet i filen $file
medan du läser rad
do
echo $line>> $fil
Gjort
medan loop i Linux
Så från exemplet ovan kunde vi skriva in text i en fil med hjälp av en while loop och läskommando. För att lämna slingan och spara ändringar i filen använder vi CTRL+D-tangenterna, och för att lämna slingan utan att spara något i filen kan vi använda CTRL+C-tangenterna. Således skriver vi in texten från kommandoraden till textfilen med hjälp av read-kommandot och en while-loop.
Bryt och fortsätt använda medan loop
Break and continue är väsentliga i ett program som hanterar loop-satser eftersom de styr flödet av loop-satser utan några explicita villkor.
Bryt uttalande i While Loop
Vi använder break-satser för att lämna loopen utan att vänta på att tillståndet för while-loopen ska utvärderas till falskt. Denna sats kan användas inom ett loopblock. Detta kan användas för att lämna en oändlig slinga med ett programmatiskt tillstånd inuti slingan och på så sätt behålla kontrollen över slingan.
Vi har till exempel ett manus som räknas från 1 och för alltid. Men vi kan programmatiskt bryta ut ur slingan med hjälp av en break-sats inuti slingans kropp med ett villkor.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
i=1
medan:
do
eko $i
if [$i -eq 20]; sedan
echo Detta är slutet på slingan
ha sönder
vara
((i++))
Gjort
Break statement medan loop i Linux
Från skriptet och exekveringen kan vi se att vi kunde bryta eller lämna en oändlig loop med en villkorlig sats och break-satsen. Således används break-satsen för att få kontrollflödet för ett program/skript från insidan av en while-loop att bryta ut ur loopen utan att loopvillkoret utvärderas till false.
Fortsätt uttalande i While Loop
Vi kan använda continu-satsen för att göra motsatsen till break-satsen. Den hoppar till början av loopblocket och itererar igen. Detta kan användas för att hoppa över vissa kommandon för vissa förhållanden och tillåter därför en förändring i slingans flöde.
Till exempel, om vi har en variabel initierad till 1 och vi vill visa endast talen som är delbara med fem eller i ett visst mönster efter ett villkor, kan vi använda fortsättningssatser för att göra just det. Detta tillåter iteration över slingan på önskat sätt.
Först skapar vi en textfil med en textredigerare i Linux, i det här fallet använder vi 'vim' Text Editor.
vim while.sh
#!/usr/bin/bash
i=1
while [ $i -lt 30 ];
do
((i++))
if [[ $(( $i % 5 )) -ne 0 ]];
sedan
Fortsätta
vara
eko $i
Gjort
Fortsätt uttalande i While loop i linux
Som vi kan se continu-satsen, hoppar till början av blocket och startar exekveringen av kommandona genom att hoppa över nästa kommandon inuti blocket. While-slingan itererar endast för värdet av variabel i är mindre än 30, alltså kontrollerar if-villkoret om variabel i är delbart med 5, och om det inte är det, itererar vi om igen med hjälp av fortsätt och ökar värdet på variabeln i. De variabel i får endast ett eko om det är delbart med 5, så if-villkoret utvärderas till falskt och vi stöter inte på en continuation-sats och bär med det normala flödet av slingan. Detta görs för att undvika loggning av varje nummer och skriv endast ut de nummer som inte följer ett mönster eller villkor i if-satsen eller andra villkorssatser.
Vanliga frågor
1. Vad är en ` while`> loop i Bash-skript?
A while> loop är en kontrollflödessats i Bash-skript som tillåter att ett visst kodblock exekveras upprepade gånger så länge som ett angivet villkor är sant. Slingan ger ett sätt att automatisera repetitiva uppgifter och är en grundläggande konstruktion inom skript och programmering.
2. Hur fungerar syntaxen för en ` while`> loop look i Bash?
Den grundläggande syntaxen för a while> loop i Bash är som följer:
medan [villkor]
do
# Kod som ska köras medan villkoret är sant
Gjort
Den ` condition`> är ett test som sker före varje iteration av slingan. Om villkoret är sant exekveras koden i slingan. Om villkoret är falskt avslutas loopen och skriptet fortsätter med nästa kommando efter ` done`> påstående.
3. Vilken roll har ` (( ... ))`> konstruera i en Bash while> slinga?
Den ` (( ... ))`> konstruktion i Bash används för aritmetiska operationer. I samband med en ` while`> loop, används den ofta för att utvärdera aritmetiska förhållanden.
Till exempel: ` ((i <10))> `> kontrollerar om variabeln ` i`> är mindre än 10. Detta gör att du kan använda aritmetiska uttryck direkt i looptillståndet, vilket gör det särskilt användbart när du hanterar numeriska jämförelser.
4. Hur man skapar en oändlig loop med ` while`> i Bash?
En oändlig loop i Bash kan skapas genom att tillhandahålla ett villkor som alltid utvärderas till sant.
Till exempel:
medan det är sant
do
# Kod för den oändliga slingan
Gjort
Alternativt kan du använda en konstant som inte är noll i villkoret, som ` while [ 1 ]`> , för att uppnå samma resultat. Oändliga loopar är användbara i situationer där kontinuerlig exekvering krävs tills den manuellt avbryts.
Slutsats
I den här artikeln diskuterade vi BASH scripting while loop som visar sig vara ett mångsidigt verktyg för att exekvera ett kodblock upprepade gånger baserat på ett specificerat tillstånd. Den grundläggande syntaxen innebär att villkoret definieras inom hakparenteser, vilket möjliggör flexibla iterationer. Artikeln utforskar olika tillämpningar av while-loopar, inklusive att läsa från filer, skapa oändliga loopar, fixa iterationer, tolka kommandoradsargument och använda break and continue-satser. Från syntax i C-stil till interaktiv filskrivning, varje exempel visar loopens anpassningsförmåga för att tillgodose en rad skriptbehov. Denna omfattande översikt understryker while-slingans betydelse i BASH-skript, vilket ger en robust mekanism för kontrollerad upprepning och effektiv kodexekvering.
