EN mens loop er en sætning, der itererer over en kodeblok, indtil den angivne betingelse evalueres til falsk. Vi kan bruge denne erklæring eller løkke i vores program, når vi ikke ved, hvor mange gange tilstanden vil evalueres til sand, før den evalueres til falsk.

Indholdsfortegnelse

• Syntaksen for en while-løkke i BASH Scripting
• Looping Eksempel med while-sætning i Linux
• Læser en fil med en while-løkke
• Uendelig mens-løkke
• Mens sløjfe for at iterere et fast antal gange
• Læs kommandolinjeargumentet med getopts-indstillinger
• C-stil mens loop
• Mens loop for at udføre handlinger på en fil
• Skrivning til en fil ved hjælp af en while-løkke
• Bryd og fortsæt med at bruge mens Loop
• Ofte stillede spørgsmål

Syntaksen for en while-løkke i BASH Scripting

while [ condition ]; do  # statements  # commands done>

Hvis betingelsen er sand, udføres kommandoerne inde i while-blokken og gentages igen efter kontrol af betingelsen. Også hvis betingelsen er falsk, springes sætningerne inde i while-blokken over, og sætningerne efter while-blokken udføres.

Looping Eksempel med while-sætning i Linux

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash

a=7
mens [$a -gt 4];
gør
ekko $a
((en-))
Færdig
ekko Ud af løkken

Forklaring:

• #!/usr/bin/bash> : Denne linje kaldes en shebang og angiver stien til tolken, der skal bruges til at udføre scriptet. I dette tilfælde specificerer det, at Bash-skallen skal bruges.
• a=7> : Initialiserer en variabel med navna>med værdien 7.
• while [ $a -gt 4 ];> : Starter en while-løkke, der fortsætter så længe værdien afa>er større end 4.
• do> : Markerer begyndelsen af ​​kodeblokken, der skal udføres i while-løkken.
• echo $a> : Udskriver den aktuelle værdi af variablena>til konsollen.
• ((a--))> : Sænker værdien afa>af 1. Dette er en stenografisk måde at skrive påa=$((a - 1))>.
• done> : Markerer slutningen af ​​kodeblokken for while-løkken.
• echo 'Out of the loop'> : Udskriver ud af løkken til konsollen, efter mens løkken er afsluttet.

Mens Loop i Linux

Sammenfattende initialiserer dette script en variabel ` a`> med værdien 7, går derefter ind i en while-løkke, der fortsætter så længe som ` a`> er større end 4. Inden for løkken udskriver den den aktuelle værdi af ` a`> og formindsker den med 1 i hver iteration. En gang ` a`> bliver 4 eller mindre, afsluttes løkken, og scriptet udskrives ud af løkken til konsollen.

Læser en fil med en while-løkke

Vi kan læse en fil med en while-løkke i BASH. Ved at parse visse parametre til while-løkkebetingelsen kan vi iterere over filen linje for linje eller efter andre grupper som tegn eller ord.

gør et shell-script eksekverbart

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash

file=temp.txt
mens du læser -r linje;
gør
echo $line
færdig <$fil

Forklaring:

• #!/usr/bin/bash> : Denne shebang-linje angiver, at Bash-skallen skal bruges til at fortolke scriptet.
• file=temp.txt> : Tildeler strengen temp.txt til variablenfile>, der repræsenterer navnet på den fil, der skal læses.
• while read -r line;> : Starter en while-løkke, der læser hver linje fra den angivne fil.
• do> : Markerer begyndelsen af ​​kodeblokken, der skal udføres i while-løkken.
• echo $line> : Udskriver indholdet af variablenline>, som repræsenterer den aktuelle linje, der læses fra filen, til konsollen.
• done> : Markerer slutningen af ​​kodeblokken for while-løkken.
• <'$file'> : Omdirigerer input fra while-løkken til at komme fra den angivne fil, i dette tilfælde temp.txt.

Sammenfattende læser dette script hver linje fra filen temp.txt og udskriver den til konsollen, indtil der ikke er flere linjer tilbage i filen. Det-r>mulighed medread>kommandoen bruges til at sikre, at omvendte skråstreg i inputtet behandles som bogstavelige tegn.

læs fil ved hjælp af while-sætning i Linux

Vi bruger kommandoen read til faktisk at hente linjerne eller tegnene fra filen. Read-kommandoen sendes med -r-argumentet, som ignorerer escape af tegn, hvis vises, og derfor analyseres det som sin. Vi læser en linje fra en fil nævnt efter den færdige erklæring. Read-kommandoen læser en linje fra den nævnte fil, og while-løkkerne slutter, når den sidste linje fra filen er læst (der er ingen linje tilbage at læse).

Sådan kan vi læse indholdet af filen ved hjælp af en while-løkke i BASH.

Uendelig mens-løkke

At oprette en uendelig løkke ved hjælp af en while-løkke-sætning. Vi behøver ikke at sætte nogen betingelse i while-løkken, og derfor gentager løkken uendeligt. Nedenstående er eksemplet på en uendelig mens-løkke:

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash
mens :
gør
ekko En uendelig sløjfe
# Vi kan trykke på Ctrl + C for at afslutte scriptet
Færdig

Forklaring:

• #!/usr/bin/bash> : Shebang-linjen angiver, at Bash-skallen skal bruges til at fortolke scriptet.
• while :> : Starter en uendelig løkke. Det:>(kolon) er en indbygget shell-kommando, der altid returnerer sand, hvilket effektivt skaber en uendelig løkke.
• do> : Markerer begyndelsen af ​​den kodeblok, der skal udføres i den uendelige sløjfe.
• echo 'An Infinite loop'> : Udskriver strengen En uendelig løkke til konsollen i hver iteration af løkken.
• # We can press Ctrl + C to exit the script> : Dette er en kommentar, der indikerer, at du kan afbryde scriptet ved at trykke på Ctrl + C i terminalen. Ctrl + C er en almindelig måde at afbryde og afslutte kørende scripts i terminalen.
• done> : Markerer slutningen af ​​kodeblokken for den uendelige sløjfe.

Sammenfattende opretter dette script en uendelig løkke, der kontinuerligt ekkoer beskeden En uendelig løkke til konsollen. Sløjfen kan afbrydes og scriptet afsluttes ved at trykke på Ctrl + C i terminalen.

Infinite loop ved hjælp af While Statement i Linux

Så while-løkken i scriptet vil iterere i uendelig tid. Vi kan manuelt bryde løkken eller scriptet med CTRL + C.

Mens sløjfe for at iterere et fast antal gange

Vi kan bruge en while-løkke til at iterere over et fast antal gange, vi kan indstille betingelsen til at være -le eller mindre end lig med et tal, og løkken vil iterere, indtil iteratoren er mindre end eller lig med det tal, der er angivet i betingelsen. Vi er også nødt til at øge iteratoren manuelt for at holde loop iteratoren tikkende, ellers vil loopen fortsætte for evigt.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash

i=1

# tallet 4 kan være grænsen til

# gentag løkken

mens [$i -le 4];
gør
ekko $i
((i++))
Færdig

list.sort java

Forklaring:

• #!/usr/bin/bash> : Shebang-linjen angiver, at Bash-skallen skal bruges til at fortolke scriptet.
• i=1> : Initialiserer en variabel med navni>med værdien 1.
• while [ $i -le 4 ];> : Starter en while-løkke, der fortsætter så længe værdien afi>er mindre end eller lig med 4.
• do> : Markerer begyndelsen af ​​kodeblokken, der skal udføres i while-løkken.
• echo $i> : Udskriver den aktuelle værdi af variableni>til konsollen.
• ((i++))> : Øger værdien afi>af 1. Dette er en stenografisk måde at skrive påi=$((i + 1))>.
• done> : Markerer slutningen af ​​kodeblokken for while-løkken.

mens loop i Linux

I ovenstående eksempel kan vi se, at løkken itererer et defineret antal gange. Da vi har initialiseret tælleren til 1, og betingelsen er at iterere løkken, indtil iteratoren er mindre end eller lig med tallet i dette tilfælde 4. Således kan vi ændre tallet i betingelsen i henhold til vores krav.

Læs kommandolinjeargumentet med getopts-indstillinger

Vi kan bruge get ops-indstillinger til at læse input fra kommandolinjen, og hvis der er flere argumenter, kan vi kontrollere dem og analysere dem én efter én ved hjælp af en while-løkke. getopts er et værktøj til at få brugerinput fra kommandolinjen. Vi kan have flere muligheder for at parse fra kommandolinjen, og ved at bruge getopts og while-løkker kan vi lave et professionelt udseende brugerinputprogram.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/bin/bash

mens getopts n:a: OPT
gør
sag ${OPT} i
n) navn=${OPTARG} ;;
a) alder=${OPTARG} ;;
*) echo Ugyldig mulighed
udgang 1;;
esac
Færdig
printf Mit navn er $name og jeg er $age år gammel

Forklaring:

• #!/bin/bash> : Shebang-linjen angiver, at Bash-skallen skal bruges til at fortolke scriptet.
• while getopts n:a: OPT> : Starter en loop, der brugergetopts>for at analysere kommandolinjeindstillinger. De angivne muligheder ern>oga>, som begge forventes at blive efterfulgt af et argument.
• do> : Markerer begyndelsen af ​​den kodeblok, der skal udføres i løkken.
• case '${OPT}' in> : Starter en case-sætning, der evaluerer værdien af ​​den mulighed, der stødes pågetopts>.
• n) name=${OPTARG};;> : Hvis muligheden er-n>, tildeler værdien af ​​det tilsvarende argument til variablenname>.
• a) age=${OPTARG};;> : Hvis muligheden er-a>, tildeler værdien af ​​det tilsvarende argument til variablenage>.
• *) echo 'Invalid option'> : Hvis der stødes på en ugyldig indstilling, udskrives en fejlmeddelelse til konsollen.
• exit 1;;> : Forlader scriptet med en statuskode, der ikke er nul, hvilket indikerer en fejl.
• esac> : Afslutter sagsfremstillingen.
• done> : Markerer slutningen af ​​kodeblokken for løkken.
• printf 'My name is $name and am $age years old '> : Udskriver en formateret besked til konsollen ved hjælp af værdierne ` name`> og ` age`> hentet fra kommandolinjeindstillingerne.

Mens loop i Linux

I dette tilfælde har vi to muligheder, nemlig navnet og alderen, du kan have flere muligheder. Vi er nødt til at specificere, hvilken mulighed vi skal bruge switch case-sætningerne og fra kommandolinjen ved at bruge -shorthand option. I dette tilfælde har vi brugt -n for navn og -a for alder . Vi har også en standard eller ugyldig kasuskontrol for at tåle, at vi ikke analyserer forkerte argumenter. Vi kan tildele værdien af ​​optionen ved hjælp af OPTARG variabel, som analyserer den værdi, der er givet til optionen.

While-løkken her bruges til at iterere, indtil der ikke er nogen indstillinger sendt fra kommandolinjen. Vi tjekker for valgmuligheden -n og -a og itererer, indtil der trykkes på vognretur- eller enter-tasten, og der ikke er flere muligheder, der skal analyseres.

C-stil mens loop

Vi kan bruge C-stilet while-løkke i BASH, variablerne skal evalueres med BASH-stilen, men den overordnede syntaks føles som C. Vi kan bruge operatorerne som ,<= og så videre i while-løkkens tilstand og dermed det kaldes ligesom den C-stilede while-løkke.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim c-style-while.sh>

#!/bin/bash
i=0
mens ((i <12))
gør
ekko $i
((i+=2))
Færdig

c-stil-mens

I dette eksempel kan vi se, at while-løkken har en betingelse med ikke-bash-operatorer som -le, -ge osv., i stedet bruger vi de C-stilede operatorer i betingelsen. Resten af ​​løkken er den grundlæggende løkke som i BASH, variablen eller iteratoren i øges med to, som vi kan se i den sidste sætning af løkkens krop. Løkken itererer således over 5 gange.

Mens loop for at udføre handlinger på en fil

Vi kan udføre operationer på en fil, som kun at læse en bestemt del af en fil. Hvis vi har kolonner, der er formateret på en bestemt måde, kan vi bruge variabler til at tildele dem og udskrive dem én række datatid.

Her er eksempelfilnavnet wh.txt

vim wh.txt>

vi opretter en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' teksteditor.

vim file-while.sh>

Sprogtype frigivet

Python general 1991

Javascript web 1995

Java mobil 1995

Rust indlejret 2010

Gå backend 2007

vi opretter en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' teksteditor.

vim file-while.sh>

#!/bin/bash

mens du læser a b c
gør
ekko $b – $a
Færdig

Mens loop i Linux

I dette eksempel har vi tre rækker, vi læser indholdet ved at tildele dem til variablerne a,b og c, det kan være alt hvad du kan lide, men husk at bruge dem i loop-kroppen. Vi kan vælge en bestemt kolonne som b og a og kan udskrive eller udføre enhver handling på dem. Dette vil dog ikke blive afspejlet i filen, da de kun er de lokale scriptvariabler.

solrig deol

Skrivning til en fil ved hjælp af en while-løkke

Vi kan skrive til en fil ved hjælp af brugerinput i en while-løkke. Vi kan bruge while-løkken til at iterere, indtil vi manuelt går ud af løkken ved hjælp af CTRL + D ved at gemme ændringer i filen eller ved at CTRL + C for at undgå at skrive til filen. Vi bruger read-kommandoen til at indtaste teksten fra kommandolinjen og parse den til filen.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim write-wh.sh>

#! /bin/bash

file=wh.txt
echo Indtast indholdet i filen $file
mens du læser linje
gør
echo $line>> $fil
Færdig

mens loop i Linux

Så fra eksemplet ovenfor var vi i stand til at indtaste tekst i en fil ved hjælp af en while-løkke og læsekommando. For at forlade løkken og gemme ændringer i filen bruger vi CTRL+D-tasterne, og for at gå ud af løkken uden at gemme noget i filen kan vi bruge CTRL+C-tasterne. Således indtaster vi teksten fra kommandolinjen til tekstfilen ved hjælp af read-kommandoen og en while-løkke.

Bryd og fortsæt med at bruge mens Loop

Break and continue er afgørende i et program, der beskæftiger sig med loop-sætninger, da de styrer flowet af loop-sætningerne uden nogen eksplicitte betingelser.

Break statement i While Loop

Vi bruger break-sætninger til at gå ud af løkken uden at vente på, at while-løkkens tilstand evalueres til falsk. Denne sætning kan bruges inden for en sløjfeblok. Dette kan bruges til at gå ud af en uendelig løkke med en programmatisk tilstand inde i løkken og dermed bevare kontrollen over løkken.

For eksempel har vi et script, der tæller fra 1 og til evig tid. Men vi kan programmatisk bryde ud af løkken ved hjælp af en break-sætning inde i løkkens krop med en betingelse.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash

i=1
mens :
gør
ekko $i
if [$i -eq 20]; derefter
echo Dette er slutningen af ​​løkken
pause
være
((i++))
Færdig

Break statement mens loop i Linux

Fra scriptet og udførelsen kan vi se, at vi var i stand til at bryde eller afslutte en uendelig løkke med en betinget sætning og break-sætningen. Således bruges break-sætningen til at få kontrolflowet af et program/script inde fra en while-løkke til at bryde ud af loopet, uden at loop-tilstanden evalueres til falsk.

netværk og internet

Fortsæt udtalelsen i While Loop

Vi kan bruge fortsæt-sætningen til at gøre det modsatte af pausesætningen. Det vil springe til starten af ​​loop-blokken og iterere igen. Dette kan bruges til at springe over bestemte kommandoer under visse forhold og tillader derfor en ændring i løkkens flow.

For eksempel, hvis vi har en variabel initialiseret til 1, og vi kun vil vise de tal, der er delelige med fem eller i et bestemt mønster efter en betingelse, kan vi bruge fortsæt-sætninger til at gøre netop det. Dette tillader iteration over løkken på den ønskede måde.

Først opretter vi en tekstfil ved hjælp af en teksteditor i Linux, i dette tilfælde bruger vi 'vim' Text Editor.

vim while.sh>

#!/usr/bin/bash

i=1
mens [$i -lt 30];
gør
((i++))
if [[ $(( $i % 5 )) -ne 0 ]];
derefter
Blive ved
være
ekko $i
Færdig

Fortsæt Statement i While loop i linux

Som vi kan se fortsætte-sætningen, hopper til begyndelsen af ​​blokken og starter udførelsen af ​​kommandoerne ved at springe de næste kommandoer over i blokken. While-løkken itererer kun for værdien af variabel i er mindre end 30, så if-tilstanden kontrollerer, om variabel i er deleligt med 5, og hvis det ikke er det, itererer vi igen med fortsæt og øger værdien af ​​variablen i. Det variabel i får kun ekko, hvis det er deleligt med 5, så if-tilstanden vurderes til falsk, og vi støder ikke på en fortsæt-sætning og bærer med det normale flow af sløjfen. Dette gøres for at undgå logning af hvert tal og kun udskrive de tal, der ikke følger et mønster eller en betingelse i if-sætningen eller andre betingede udsagn.

Ofte stillede spørgsmål

1. Hvad er en ` while`> loop i Bash scripting?

ENwhile>loop er en kontrol-flow-sætning i Bash-scripting, der tillader, at en bestemt blok kode kan udføres gentagne gange, så længe en specificeret betingelse er sand. Sløjfen giver en måde at automatisere gentagne opgaver og er en grundlæggende konstruktion i scripting og programmering.

2. Hvordan virker syntaksen for en ` while`> loop look i Bash?

Den grundlæggende syntaks for enwhile>loop i Bash er som følger:

mens [ tilstand ]
gør
# Kode, der skal udføres, mens betingelsen er sand
Færdig

Den ` condition`> er en test, der finder sted før hver iteration af løkken. Hvis betingelsen er sand, udføres koden i løkken. Hvis betingelsen er falsk, afsluttes løkken, og scriptet fortsætter med den næste kommando efter ` done`> udmelding.

3. Hvad er rollen for ` (( ... ))`> konstruere i en Bash while> sløjfe?

Den ` (( ... ))`> konstruktion i Bash bruges til aritmetiske operationer. I forbindelse med en ` while`> loop, bruges den ofte til at evaluere aritmetiske betingelser.

For eksempel: ` ((i <10))> `>kontrollerer om variablen ` i`> er mindre end 10. Dette giver dig mulighed for at bruge aritmetiske udtryk direkte i loop-tilstanden, hvilket gør det særligt nyttigt, når du har med numeriske sammenligninger at gøre.

4. Sådan opretter du en uendelig løkke ved hjælp af ` while`> i Bash?

En uendelig løkke i Bash kan skabes ved at give en betingelse, der altid evalueres til sand.

For eksempel:

mens sandt
gør
# Kode for den uendelige løkke
Færdig

Alternativt kan du bruge en konstant, der ikke er nul i tilstanden, f.eks ` while [ 1 ]`> , for at opnå samme resultat. Uendelige loops er nyttige i situationer, hvor kontinuerlig udførelse er påkrævet, indtil den afbrydes manuelt.

Konklusion

I denne artikel diskuterede vi BASH scripting while loop, som viser sig at være et alsidigt værktøj til at udføre en blok kode gentagne gange baseret på en specificeret betingelse. Den grundlæggende syntaks involverer at definere betingelsen inden for firkantede parenteser, hvilket giver mulighed for fleksible iterationer. Artiklen udforsker forskellige anvendelser af while-løkker, herunder læsning fra filer, oprettelse af uendelige løkker, faste iterationer, parsing af kommandolinjeargumenter og brug af break- og fortsæt-sætninger. Fra C-stil syntaks til interaktiv filskrivning demonstrerer hvert eksempel løkkens tilpasningsevne til at imødekomme en række scriptingbehov. Denne omfattende oversigt understreger while-løkkens betydning i BASH-scripting, hvilket giver en robust mekanisme til kontrolleret gentagelse og effektiv kodeudførelse.