Bash Scripting – While Loop
EN mens loop er en setning som itererer over en kodeblokk til den spesifiserte tilstanden blir evaluert til falsk. Vi kan bruke denne setningen eller løkken i programmet vårt når vi ikke vet hvor mange ganger tilstanden skal evalueres til sann før den evalueres til usann.
Innholdsfortegnelse
- Syntaksen til en while-løkke i BASH-skripting
- Looping Eksempel med while-setning i Linux
- Leser en fil med en while-løkke
- Uendelig while-løkke
- Mens loop for å iterere et fast antall ganger
- Les kommandolinjeargumentet med getopts-alternativer
- C-stil mens loop
- Mens loop for å utføre operasjoner på en fil
- Skrive til en fil ved hjelp av en while-løkke
- Bryt og fortsett å bruke mens loop
- Ofte stilte spørsmål
Syntaksen til en while-løkke i BASH-skripting
while [ condition ]; do # statements # commands done
Hvis betingelsen er sann, utføres kommandoene inne i while-blokken og gjentas etter kontroll av betingelsen. Også hvis betingelsen er usann, blir setningene i while-blokken hoppet over og setningene etter while-blokken blir utført.
Looping Eksempel med while-setning i Linux
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
a=7
while [ $a -gt 4 ];
gjøre
ekko $a
((en-))
ferdig
ekko Ut av loopen
Forklaring:
-
#!/usr/bin/bash>: Denne linjen kalles en shebang og indikerer banen til tolken som skal brukes for å utføre skriptet. I dette tilfellet spesifiserer det at Bash-skallet skal brukes. -
a=7>: Initialiserer en variabel med navna>med verdien 7. -
while [ $a -gt 4 ];>: Starter en while-løkke som fortsetter så lenge verdien ava>er større enn 4. -
do>: Markerer begynnelsen av kodeblokken som skal utføres innenfor while-løkken. -
echo $a>: Skriver ut gjeldende verdi av variabelena>til konsollen. -
((a--))>: Reduserer verdien ava>av 1. Dette er en stenografisk måte å skrive påa=$((a - 1))>. -
done>: Markerer slutten av kodeblokken for while-løkken. -
echo 'Out of the loop'>: Skriver ut av sløyfen til konsollen etter at while-sløyfen er fullført.
Mens Loop i Linux
Oppsummert initialiserer dette skriptet en variabel ` a`> med verdien 7, går deretter inn i en while-løkke som fortsetter så lenge som ` a`> er større enn 4. Innenfor loopen skriver den ut gjeldende verdi på ` a`> og reduserer den med 1 i hver iterasjon. En gang ` a`> blir 4 eller mindre, går løkken ut, og skriptet skrives ut av løkken til konsollen.
Leser en fil med en while-løkke
Vi kan lese en fil med en while-løkke i BASH. Ved å analysere visse parametere til while-løkkebetingelsen, kan vi iterere over filen linje for linje eller etter andre grupper som tegn eller ord.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
file=temp.txt
mens les -r linje;
gjøre
ekko $line
ferdig <$fil
Forklaring:
-
#!/usr/bin/bash>: Denne shebang-linjen spesifiserer at Bash-skallet skal brukes til å tolke skriptet. -
file=temp.txt>: Tildeler strengen temp.txt til variabelenfile>, som representerer navnet på filen som skal leses. -
while read -r line;>: Starter en while-løkke som leser hver linje fra den angitte filen. -
do>: Markerer begynnelsen av kodeblokken som skal utføres innenfor while-løkken. -
echo $line>: Skriver ut innholdet i variabelenline>, som representerer gjeldende linje som leses fra filen, til konsollen. -
done>: Markerer slutten av kodeblokken for while-løkken. -
<'$file'>: Omdirigerer inngangen til while-løkken til å komme fra den spesifiserte filen, i dette tilfellet temp.txt.
Oppsummert leser dette skriptet hver linje fra filen temp.txt og skriver den ut til konsollen til det ikke er flere linjer igjen i filen. De -r> alternativet med read> kommandoen brukes for å sikre at omvendte skråstreker i inndata behandles som bokstavelige tegn.
les fil med while-setning i Linux
Vi bruker kommandoen read for å faktisk hente linjene eller tegnene fra filen. Lesekommandoen sendes med -r-argumentet som ignorerer escape av tegn hvis vises, og derfor analyseres det som sin. Vi leser en linje fra en fil nevnt etter den ferdige uttalelsen. Read-kommandoen leser en linje fra den nevnte filen og while-løkkene slutter når den siste linjen fra filen er lest (ingen linje er igjen å lese).
Slik kan vi lese innholdet i filen ved å bruke en while-løkke i BASH.
Uendelig while-løkke
For å lage en uendelig sløyfe ved hjelp av en while loop-setning. Vi trenger ikke å sette noen betingelse i while-løkken, og derfor itererer løkken uendelig. Nedenfor er eksempelet på en uendelig mens-løkke:
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
samtidig som :
gjøre
ekko En uendelig loop
# Vi kan trykke Ctrl + C for å avslutte skriptet
ferdig
Forklaring:
-
#!/usr/bin/bash>: Shebang-linjen spesifiserer at Bash-skallet skal brukes til å tolke skriptet. -
while :>: Starter en uendelig sløyfe. De:>(kolon) er en innebygd kommando som alltid returnerer sann, og skaper effektivt en uendelig løkke. -
do>: Markerer begynnelsen av kodeblokken som skal utføres innenfor den uendelige sløyfen. -
echo 'An Infinite loop'>: Skriver ut strengen An Infinite loop til konsollen i hver iterasjon av loopen. -
# We can press Ctrl + C to exit the script>: Dette er en kommentar som indikerer at du kan avbryte skriptet ved å trykke Ctrl + C i terminalen. Ctrl + C er en vanlig måte å avbryte og avslutte kjørende skript i terminalen. -
done>: Markerer slutten av kodeblokken for den uendelige sløyfen.
Oppsummert skaper dette skriptet en uendelig sløyfe som kontinuerlig ekkoer meldingen An Infinite loop til konsollen. Sløyfen kan avbrytes og skriptet avsluttes ved å trykke Ctrl + C i terminalen.
Uendelig loop ved å bruke While Statement i Linux
Dermed kommer while-løkken i skriptet til å iterere i uendelig tid. Vi kan bryte sløyfen eller skriptet manuelt med CTRL + C.
Mens loop for å iterere et fast antall ganger
Vi kan bruke en while-løkke til å iterere over et fast antall ganger, vi kan sette betingelsen til å være -le eller mindre enn lik et tall, og løkken vil iterere til iteratoren er mindre enn eller lik tallet gitt i tilstanden. Vi må også øke iteratoren manuelt for å holde loop-iteratoren tikkende, ellers vil loopen fortsette for alltid.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
i=1
# tallet 4 kan være grensen til
# gjenta loopen
while [ $i -le 4 ];
gjøre
ekko $i
((i++))
ferdig
Forklaring:
-
#!/usr/bin/bash>: Shebang-linjen spesifiserer at Bash-skallet skal brukes til å tolke skriptet. -
i=1>: Initialiserer en variabel med navni>med verdien 1. -
while [ $i -le 4 ];>: Starter en while-løkke som fortsetter så lenge verdien avi>er mindre enn eller lik 4. -
do>: Markerer begynnelsen av kodeblokken som skal utføres innenfor while-løkken. -
echo $i>: Skriver ut gjeldende verdi av variabeleni>til konsollen. -
((i++))>: Øker verdien avi>av 1. Dette er en stenografisk måte å skrive påi=$((i + 1))>. -
done>: Markerer slutten av kodeblokken for while-løkken.
mens loop i Linux
I eksemplet ovenfor kan vi se at loopen itererer et definert antall ganger. Ettersom vi har initialisert telleren til 1 og betingelsen er å iterere sløyfen til iteratoren er mindre enn eller lik tallet i dette tilfellet 4. Dermed kan vi endre tallet i betingelsen i henhold til vårt krav.
Les kommandolinjeargumentet med getopts-alternativer
Vi kan bruke get ops-alternativer for å lese inndataene fra kommandolinjen, og hvis det er flere argumenter, kan vi sjekke dem og analysere dem en etter en ved å bruke en while-løkke. getopts er et verktøy for å få brukerinndata fra kommandolinjen. Vi kan ha flere alternativer for å analysere fra kommandolinjen, og ved å bruke getopts og while-løkker kan vi lage et profesjonelt utseende brukerinndataprogram.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/bin/bash
mens getopts n:a: OPT
gjøre
sak ${OPT} i
n) navn=${OPTARG} ;;
a) alder=${OPTARG} ;;
*) echo Ugyldig alternativ
utgang 1 ;;
esac
ferdig
printf Mitt navn er $name og jeg er $age år gammel
Forklaring:
-
#!/bin/bash>: Shebang-linjen spesifiserer at Bash-skallet skal brukes til å tolke skriptet. -
while getopts n:a: OPT>: Starter en loop som brukergetopts>for å analysere kommandolinjealternativer. Alternativene som er spesifisert ern>oga>, som begge forventes å bli fulgt av et argument. -
do>: Markerer begynnelsen av kodeblokken som skal utføres i løkken. -
case '${OPT}' in>: Starter en sakserklæring som evaluerer verdien av alternativet som oppstår avgetopts>. -
n) name=${OPTARG};;>: Hvis alternativet er-n>, tildeler verdien av det tilsvarende argumentet til variabelenname>. -
a) age=${OPTARG};;>: Hvis alternativet er-a>, tildeler verdien av det tilsvarende argumentet til variabelenage>. -
*) echo 'Invalid option'>: Hvis det oppstår et ugyldig alternativ, skrives det ut en feilmelding til konsollen. -
exit 1;;>: Går ut av skriptet med en statuskode som ikke er null, noe som indikerer en feil. -
esac>: Avslutter saksuttalelsen. -
done>: Markerer slutten av kodeblokken for sløyfen. -
printf 'My name is $name and am $age years old '>: Skriver ut en formatert melding til konsollen ved å bruke verdiene for `name`>og `age`>hentet fra kommandolinjealternativene.
Mens loop i Linux
I dette tilfellet har vi to alternativer, nemlig navnet og alderen, du kan ha flere alternativer. Vi må spesifisere hvilket alternativ vi skal bruke switch case-setningene og fra kommandolinjen ved å bruke -shorthand-alternativet. I dette tilfellet har vi brukt -n for navn og -a for alder . Vi har også en standard eller ugyldig kasussjekk for å tåle at vi ikke analyserer feil argumenter. Vi kan tilordne verdien av alternativet ved å bruke OPTARG variabel som analyserer verdien gitt til alternativet.
While-løkken her brukes til å iterere til det ikke er noen alternativer sendt fra kommandolinjen. Vi sjekker for alternativene -n og -a og itererer til vognretur- eller enter-tasten trykkes og det ikke er flere alternativer som skal analyseres.
C-stil mens loop
Vi kan bruke C-stilt while-løkke i BASH, variablene må evalueres med BASH-stil, men den generelle syntaksen føles som C. Vi kan bruke operatorene som , <= og så videre i tilstanden til while-løkken og derav det kalles som den C-stilte while-løkken.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim c-style-while.sh
#!/bin/bash
i=0
mens ((i <12))
gjøre
ekko $i
((i+=2))
ferdig
c-stil-mens
I dette eksemplet kan vi se at while-løkken har en betingelse med ikke-bash-operatorer som -le, -ge, etc., i stedet bruker vi de C-stilte operatorene i betingelsen. Resten av løkken er den grunnleggende løkken som i BASH, variabelen eller iteratoren i økes med to som vi kan se i den siste setningen til løkkekroppen. Dermed går løkken over 5 ganger.
Mens loop for å utføre operasjoner på en fil
Vi kan utføre operasjoner på en fil, som å lese bare en bestemt del av en fil. Hvis vi har kolonner som er formatert på en bestemt måte, kan vi bruke variabler til å tilordne dem og skrive dem ut én rad datatid.
Her er eksempelfilnavnet wh.txt
vim wh.txt
vi lager en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi `vim` tekstredigering.
vim file-while.sh
Språktype utgitt
Python general 1991
Javascript web 1995
Java mobil 1995
Rust innebygd 2010
Gå backend 2007
vi lager en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi `vim` tekstredigering.
vim file-while.sh
#!/bin/bash
mens du leser a b c
gjøre
ekko $b – $a
ferdig
Mens loop i Linux
I dette eksemplet har vi tre rader, vi leser innholdet ved å tilordne dem til variablene a,b og c, det kan være alt du liker, men husk å bruke dem i loop-kroppen. Vi kan velge en bestemt kolonne som b og a og kan skrive ut eller utføre alle operasjoner på dem. Dette vil imidlertid ikke gjenspeiles i filen, da de bare er de lokale skriptvariablene.
Skrive til en fil ved hjelp av en while-løkke
Vi kan skrive til en fil ved brukerinndata i en while-løkke. Vi kan bruke while-løkken til å iterere til vi manuelt går ut av loopen ved å bruke CTRL + D ved å lagre endringer i filen eller ved å CTRL + C for å unngå å skrive til filen. Vi bruker lese-kommandoen til å legge inn teksten fra kommandolinjen og analysere den til filen.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim write-wh.sh
#! /bin/bash
file=wh.txt
echo Skriv inn innholdet i filen $file
mens du leser linje
gjøre
ekko $line>> $fil
ferdig
mens loop i Linux
Så fra eksemplet ovenfor var vi i stand til å skrive inn tekst i en fil ved å bruke en while-løkke og lesekommando. For å gå ut av loopen og lagre endringer i filen bruker vi CTRL+D-tastene, og for å gå ut av loopen uten å lagre noe i filen kan vi bruke CTRL+C-tastene. Dermed legger vi inn teksten fra kommandolinjen til tekstfilen ved å bruke lesekommandoen og en while-løkke.
Bryt og fortsett å bruke mens loop
Break and continue er avgjørende i et program som omhandler loop-setninger da de kontrollerer flyten av loop-setningene uten noen eksplisitte betingelser.
Bryt uttalelse i While Loop
Vi bruker break-setninger for å gå ut av loopen uten å vente på at tilstanden til while-løkken skal evalueres til falsk. Denne setningen kan brukes i en sløyfeblokk. Denne kan brukes til å gå ut av en uendelig sløyfe med en programmatisk tilstand inne i sløyfen og dermed opprettholde kontrollen over sløyfen.
For eksempel har vi et skript som teller fra 1 og for alltid. Men vi kan programmatisk bryte ut av løkken ved å bruke en break-setning inne i løkken med en betingelse.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
i=1
samtidig som :
gjøre
ekko $i
if [$i -eq 20]; deretter
echo Dette er slutten av loopen
gå i stykker
være
((i++))
ferdig
Break statement mens loop i Linux
Fra skriptet og utførelsen kan vi se at vi var i stand til å bryte eller gå ut av en uendelig sløyfe med en betinget setning og break-setningen. Derfor brukes break-setningen til å få kontrollflyten til et program/skript fra innsiden av en while-løkke til å bryte ut av loopen uten at loop-tilstanden evalueres til falsk.
Fortsett uttalelsen i While Loop
Vi kan bruke fortsett-setningen til å gjøre det motsatte av break-setningen. Den vil hoppe til starten av løkkeblokken og iterere igjen. Dette kan brukes til å hoppe over visse kommandoer for visse forhold og tillater derfor en endring i sløyfens flyt.
For eksempel, hvis vi har en variabel initialisert til 1 og vi vil vise bare tallene som er delelig med fem eller i et bestemt mønster etter en betingelse, kan vi bruke fortsett-setninger for å gjøre nettopp det. Dette tillater iterasjon over løkken på ønsket måte.
Først lager vi en tekstfil ved å bruke et tekstredigeringsprogram i Linux, i dette tilfellet bruker vi 'vim' tekstredigering.
vim while.sh
#!/usr/bin/bash
i=1
while [ $i -lt 30 ];
gjøre
((i++))
if [[ $(( $i % 5 )) -ne 0 ]];
deretter
Fortsette
være
ekko $i
ferdig
Fortsett Statement i While loop i linux
Som vi kan se fortsette-setningen, hopper til begynnelsen av blokken og starter utførelsen av kommandoene ved å hoppe over de neste kommandoene inne i blokken. While-løkken itererer kun for verdien av variabel i er mindre enn 30, og derfor kontrollerer if-tilstanden om variabel i er delelig med 5, og hvis det ikke er det, itererer vi om igjen med fortsett og øker verdien til variabelen i. De variabel i får bare ekko hvis den er delelig med 5, dermed blir if-tilstanden evaluert til falsk og vi møter ikke en fortsettelsessetning og bærer med den normale flyten av løkken. Dette gjøres for å unngå logging av hvert tall og kun skrive ut tallene som ikke følger et mønster eller en betingelse i if-setningen eller andre betingede utsagn.
Ofte stilte spørsmål
1. Hva er en ` while`> loop i Bash-skripting?
EN while> loop er en kontrollflytsetning i Bash-skripting som lar en bestemt kodeblokk utføres gjentatte ganger så lenge en spesifisert tilstand er sann. Løkken gir en måte å automatisere repeterende oppgaver og er en grunnleggende konstruksjon innen skripting og programmering.
2. Hvordan virker syntaksen til en ` while`> loop look i Bash?
Den grunnleggende syntaksen til en while> loop i Bash er som følger:
mens [ tilstand ]
gjøre
# Kode som skal utføres mens betingelsen er sann
ferdig
Den ` condition`> er en test som skjer før hver iterasjon av sløyfen. Hvis betingelsen er sann, kjøres koden i løkken. Hvis betingelsen er usann, avsluttes loopen, og skriptet fortsetter med neste kommando etter ` done`> uttalelse.
3. Hva er rollen til ` (( ... ))`> bygge i en Bash while> Løkke?
Den ` (( ... ))`> konstruksjon i Bash brukes til aritmetiske operasjoner. I sammenheng med en ` while`> loop, brukes den ofte til å evaluere aritmetiske forhold.
For eksempel: ` ((i <10))> `> sjekker om variabelen ` i`> er mindre enn 10. Dette lar deg bruke aritmetiske uttrykk direkte i løkketilstanden, noe som gjør det spesielt nyttig når du arbeider med numeriske sammenligninger.
4. Hvordan lage en uendelig løkke ved å bruke ` while`> i Bash?
En uendelig løkke i Bash kan opprettes ved å gi en betingelse som alltid evalueres til sann.
For eksempel:
mens det er sant
gjøre
# Kode for den uendelige løkken
ferdig
Alternativt kan du bruke en konstant som ikke er null i tilstanden, som ` while [ 1 ]`> , for å oppnå samme resultat. Uendelige løkker er nyttige i situasjoner der kontinuerlig utførelse er nødvendig inntil den blir manuelt avbrutt.
Konklusjon
I denne artikkelen diskuterte vi BASH scripting while loop som viser seg å være et allsidig verktøy for å utføre en blokk med kode gjentatte ganger basert på en spesifisert tilstand. Den grunnleggende syntaksen innebærer å definere betingelsen innenfor hakeparenteser, noe som gir mulighet for fleksible iterasjoner. Artikkelen utforsker ulike anvendelser av while-løkker, inkludert lesing fra filer, opprettelse av uendelige løkker, faste iterasjoner, analysering av kommandolinjeargumenter og bruk av break- og continue-setninger. Fra C-stilsyntaks til interaktiv filskriving, hvert eksempel demonstrerer loopens tilpasningsevne når det gjelder å dekke en rekke skriptbehov. Denne omfattende oversikten understreker while-løkkens betydning i BASH-skripting, og gir en robust mekanisme for kontrollert repetisjon og effektiv kodekjøring.
