A o kilpa yra teiginys, kuris kartojasi per kodo bloką, kol nurodyta sąlyga bus įvertinta kaip klaidinga. Šį teiginį arba kilpą galime naudoti savo programoje, kai nežinome, kiek kartų sąlyga bus įvertinta į teisingą, prieš įvertindama į klaidingą.

Turinys

• BASH scenarijaus tam tikro ciklo sintaksė
• Ciklo kūrimo pavyzdys naudojant while teiginį Linux sistemoje
• Failo skaitymas su while ciklu
• Begalinis o ciklas
• Nors ciklas kartojamas fiksuotą skaičių kartų
• Perskaitykite komandinės eilutės argumentą su getopts parinktimis
• C stiliaus, nors kilpa
• Nors ciklas, skirtas operacijoms su failu atlikti
• Rašymas į failą naudojant ciklą
• Nutraukite ir tęskite naudojimą, kai ciklas
• Dažnai užduodami klausimai

BASH scenarijaus tam tikro ciklo sintaksė

while [ condition ]; do  # statements  # commands done 

Jei sąlyga yra teisinga, komandos while bloke vykdomos ir patikrinus sąlygą vėl kartojamos. Taip pat, jei sąlyga klaidinga, teiginiai, esantys bloke while, yra praleidžiami, o teiginiai po while bloko vykdomi.

Ciklo kūrimo pavyzdys naudojant while teiginį Linux sistemoje

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash

a=7
o [ $a -gt 4 ];
daryti
aidas $a
((a–))
padaryta
echo Out of the loop

Paaiškinimas:

• #!/usr/bin/bash> : ši eilutė vadinama shebang ir nurodo kelią į vertėją, kuris turėtų būti naudojamas scenarijui vykdyti. Šiuo atveju nurodoma, kad reikia naudoti Bash apvalkalą.
• a=7> : inicijuoja kintamąjį pavadinimu a> su 7 verte.
• while [ $a -gt 4 ];> : pradeda ciklą, kuris tęsiasi tol, kol yra reikšmė a> yra didesnis nei 4.
• do> : Pažymi kodo bloko, kuris turi būti vykdomas while cikle, pradžią.
• echo $a> : spausdina dabartinę kintamojo reikšmę a> prie konsolės.
• ((a--))> : sumažina vertę a> 1. Tai sutrumpintas rašymo būdas a=$((a - 1))> .
• done> : pažymi while ciklo kodo bloko pabaigą.
• echo 'Out of the loop'> : Pasibaigus ciklui, spausdinama iš ciklo į konsolę.

Nors ciklas „Linux“.

Apibendrinant, šis scenarijus inicijuoja kintamąjį ` a`> su reikšme 7, tada įveda ciklą, kuris tęsiasi tol, kol ` a`> yra didesnis nei 4. Ciklo viduje jis išspausdina dabartinę ` reikšmę a`> ir sumažina jį 1 kiekvienoje iteracijoje. Kartą ` a`> tampa 4 ar mažiau, ciklas išeina, o scenarijus spausdinamas iš ciklo į konsolę.

Failo skaitymas su while ciklu

BASH galime perskaityti failą su while ciklu. Analizuodami tam tikrus parametrus į while ciklo sąlygą, galime kartoti failą eilute po eilutės arba pagal kitas grupes, pvz., simbolius ar žodžius.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash

file=temp.txt
skaitant -r eilutę;
daryti
echo $line
atlikta <$failas

Paaiškinimas:

• #!/usr/bin/bash> : Ši shebang eilutė nurodo, kad scenarijui interpretuoti turėtų būti naudojamas Bash apvalkalas.
• file=temp.txt> : kintamajam priskiria eilutę temp.txt file> , nurodantis skaitytino failo pavadinimą.
• while read -r line;> : inicijuoja ciklą, kuris nuskaito kiekvieną nurodyto failo eilutę.
• do> : Pažymi kodo bloko, kuris turi būti vykdomas while cikle, pradžią.
• echo $line> : spausdina kintamojo turinį line> , kuri rodo dabartinę eilutę, kuri skaitoma iš failo į konsolę.
• done> : pažymi while ciklo kodo bloko pabaigą.
• <'$file'> : Peradresuoja while ciklo įvestį iš nurodyto failo, šiuo atveju temp.txt.

Apibendrinant, šis scenarijus nuskaito kiekvieną eilutę iš failo temp.txt ir spausdina ją į konsolę, kol faile nebelieka eilučių. The -r> variantas su read> komanda naudojama siekiant užtikrinti, kad pasvirieji brūkšniai įvestyje būtų traktuojami kaip pažodiniai simboliai.

skaitykite failą naudodami while teiginį Linux sistemoje

Mes naudojame komandą skaityti, kad iš tikrųjų gautume eilutes ar simbolius iš failo. Skaitymo komanda perduodama su -r argumentu, kuris ignoruoja simbolių pabėgimą, jei pasirodo , todėl ji analizuojama kaip jo. Perskaitome eilutę iš failo, paminėto po atlikto teiginio. Skaitymo komanda nuskaito eilutę iš minėto failo, o ciklas while baigiasi nuskaitant paskutinę failo eilutę (nelieka nuskaityti eilutės).

Taip galime nuskaityti failo turinį naudodami BASH ciklą.

Begalinis o ciklas

Norėdami sukurti begalinę ciklą, naudodami teiginį while ciklas. Mums nereikia dėti jokių sąlygų į while kilpą, todėl ciklas kartojasi be galo. Žemiau pateikiamas begalinės while ciklo pavyzdys:

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash
tuo metu:
daryti
echo Begalinė kilpa
# Norėdami išeiti iš scenarijaus, galime paspausti Ctrl + C
padaryta

Paaiškinimas:

• #!/usr/bin/bash> : Shebang eilutė nurodo, kad scenarijui interpretuoti turėtų būti naudojamas Bash apvalkalas.
• while :> : inicijuoja begalinę kilpą. The :> (dvitaškis) yra apvalkalo įtaisyta komanda, kuri visada grąžina true, efektyviai sukurdama begalinę kilpą.
• do> : pažymi kodo bloko pradžią, kuri turi būti vykdoma begaliniame cikle.
• echo 'An Infinite loop'> : spausdina eilutę Begalinis ciklas konsolėje kiekvienoje ciklo iteracijoje.
• # We can press Ctrl + C to exit the script> : Tai yra komentaras, nurodantis, kad galite nutraukti scenarijų terminale paspausdami Ctrl + C. Ctrl + C yra įprastas būdas nutraukti ir nutraukti vykdomus scenarijus terminale.
• done> : pažymi begalinio ciklo kodo bloko pabaigą.

Apibendrinant galima pasakyti, kad šis scenarijus sukuria begalinį ciklą, kuris nuolat kartoja pranešimą Begalinis ciklas į konsolę. Ciklą galima nutraukti ir scenarijų išjungti terminale paspaudus Ctrl + C.

Begalinis ciklas naudojant „ While Statement“ sistemoje „Linux“.

Taigi scenarijaus while ciklas kartosis begalinį laiką. Mes galime rankiniu būdu nutraukti kilpą arba scenarijų paspausdami CTRL + C.

Nors ciklas kartojamas fiksuotą skaičių kartų

Galime naudoti ciklą while, kad kartotume fiksuotą skaičių kartų, galime nustatyti sąlygą, kad ji būtų -le arba mažesnė nei lygi skaičiui, o ciklas kartosis tol, kol iteratorius bus mažesnis arba lygus skaičiui, pateiktam būsena. Be to, turime padidinti iteratorių rankiniu būdu, kad ciklo iteratorius tikėti, kitaip ciklas tęsis amžinai.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash

i=1

# skaičius 4 gali būti riba

# kartokite kilpą

o [ $i -le 4 ];
daryti
aidas $i
((i++))
padaryta

Paaiškinimas:

• #!/usr/bin/bash> : Shebang eilutė nurodo, kad scenarijui interpretuoti turėtų būti naudojamas Bash apvalkalas.
• i=1> : inicijuoja kintamąjį pavadinimu i> su reikšme 1.
• while [ $i -le 4 ];> : inicijuoja while kilpą, kuri tęsiasi tol, kol yra reikšmė i> yra mažesnis arba lygus 4.
• do> : Pažymi kodo bloko, kuris turi būti vykdomas while cikle, pradžią.
• echo $i> : spausdina dabartinę kintamojo reikšmę i> prie konsolės.
• ((i++))> : padidina vertę i> 1. Tai sutrumpintas rašymo būdas i=$((i + 1))> .
• done> : pažymi while ciklo kodo bloko pabaigą.

Nors ciklas „Linux“.

Aukščiau pateiktame pavyzdyje matome, kad ciklas kartojasi tam tikrą skaičių kartų. Kadangi skaitiklį inicijavome iki 1, o sąlyga yra kartoti kilpą, kol iteratorius bus mažesnis arba lygus skaičiui šiuo atveju 4. Taigi, galime pakeisti sąlygoje esantį skaičių pagal mūsų reikalavimą.

Perskaitykite komandinės eilutės argumentą su getopts parinktimis

Galime naudoti get ops parinktis, norėdami nuskaityti įvestį iš komandinės eilutės, o jei yra keli argumentai, galime juos patikrinti ir išanalizuoti po vieną, naudodami while kilpą. getopts yra įrankis, leidžiantis gauti vartotojo įvestį iš komandinės eilutės. Galime turėti kelias parinktis analizuoti iš komandinės eilutės, o naudodami getopts ir while ciklus galime sukurti profesionaliai atrodančią vartotojo įvesties programą.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/bin/bash

o getopts n:a: OPT
daryti
dėklas ${OPT} in
n) vardas=${OPTARG} ;;
a) amžius=${OPTARG} ;;
*) echo Netinkama parinktis
išėjimas 1 ;;
esac
padaryta
printf Mano vardas yra $name ir aš esu $amžiaus metų

Paaiškinimas:

• #!/bin/bash> : eilutėje shebang nurodoma, kad scenarijui interpretuoti turėtų būti naudojamas Bash apvalkalas.
• while getopts n:a: OPT> : inicijuoja kilpą, kuri naudoja getopts> išanalizuoti komandų eilutės parinktis. Nurodytos parinktys yra n> ir a> , po kurių tikimasi, kad bus argumentas.
• do> : žymi kodo bloko, kuris turi būti vykdomas cikle, pradžią.
• case '${OPT}' in> : pradeda atvejo teiginį, įvertinantį parinkties, su kuria susidūrė, reikšmę getopts> .
• n) name=${OPTARG};;> : Jei parinktis yra -n> , kintamajam priskiria atitinkamo argumento reikšmę name> .
• a) age=${OPTARG};;> : Jei parinktis yra -a> , kintamajam priskiria atitinkamo argumento reikšmę age> .
• *) echo 'Invalid option'> : jei aptinkama netinkama parinktis, konsolėje išspausdinamas klaidos pranešimas.
• exit 1;;> : išeina iš scenarijaus su nuliniu būsenos kodu, nurodant klaidą.
• esac> : baigia bylos pareiškimą.
• done> : pažymi ciklo kodo bloko pabaigą.
• printf 'My name is $name and am $age years old '> : spausdina suformatuotą pranešimą į konsolę, naudodama reikšmes ` name`> ir ` age`> gautas iš komandinės eilutės parinkčių.

Nors ciklas „Linux“.

Šiuo atveju turime dvi parinktis, būtent vardą ir amžių, galite turėti kelias parinktis. Turime nurodyti, kurią parinktį naudosime perjungimo atveju ir komandinėje eilutėje naudodami parinktį -shortand. Šiuo atveju mes naudojome -n vardui ir -a pagal amžių . Taip pat turime numatytąjį arba negaliojantį atvejo tikrinimą, kad neanalizuotume neteisingų argumentų. Parinkties vertę galime priskirti naudodami OPTARG kintamasis, kuris analizuoja parinkties reikšmę.

Nors ciklas čia naudojamas kartoti tol, kol iš komandinės eilutės nelieka parinkčių. Tikriname, ar yra -n ir -a parinktis, ir kartojame tol, kol paspaudžiamas karietos grįžimo arba įvesties klavišas ir nebelieka jokių analizuojamų parinkčių.

C stiliaus, nors kilpa

BASH galime naudoti C stiliaus while kilpą, kintamuosius reikia įvertinti naudojant BASH stilių, tačiau bendra sintaksė atrodo kaip C. Galime naudoti operatorius, pvz., , <= ir tt, kai ciklo while sąlyga. vadinama kaip C stiliaus while ciklas.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim c-style-while.sh 

#!/bin/bash
i=0
o ((i <12))
daryti
aidas $i
((i+=2))
padaryta

c-style-while

Šiame pavyzdyje matome, kad ciklas while turi sąlygą su ne „bash“ operatoriais, tokiais kaip -le, -ge ir tt, vietoj to sąlygoje naudojame C stiliaus operatorius. Likusi ciklo dalis yra pagrindinė kilpa, kaip ir BASH, kintamasis arba iteratorius i padidinamas dviem, kaip matome paskutiniame ciklo korpuso sakinyje. Taigi ciklas kartojasi daugiau nei 5 kartus.

Nors ciklas, skirtas operacijoms su failu atlikti

Galime atlikti operacijas su failu, pavyzdžiui, skaityti tik tam tikrą failo dalį. Jei turime stulpelių, kurie yra suformatuoti tam tikru būdu, galime naudoti kintamuosius, kad juos priskirtume ir atspausdintume vieną eilutę.

Čia yra failo pavadinimo wh.txt pavyzdys

vim wh.txt 

Mes kuriame tekstinį failą naudodami teksto rengyklę Linux sistemoje, šiuo atveju naudojame teksto rengyklę „vim“.

vim file-while.sh 

Išleistas kalbos tipas

Python general 1991

Javascript web 1995

Java mobilusis 1995 m

Rust embedded 2010 m

Grįžti atgal į 2007 m

Mes kuriame tekstinį failą naudodami teksto rengyklę Linux sistemoje, šiuo atveju naudojame teksto rengyklę „vim“.

vim file-while.sh 

#!/bin/bash

o skaityti a b c
daryti
aidas $b – $a
padaryta

Nors ciklas „Linux“.

Šiame pavyzdyje turime tris eilutes, skaitome turinį priskirdami juos kintamiesiems a, b ir c, tai gali būti bet kas, kas jums patinka, bet nepamirškite jų naudoti ciklo turinyje. Galime pasirinkti tam tikrą stulpelį, pvz., b ir a, ir galime su jais spausdinti arba atlikti bet kokias operacijas. Tačiau tai neatsispindės faile, nes jie yra tik vietiniai scenarijaus kintamieji.

Rašymas į failą naudojant while kilpą

Galime įrašyti į failą vartotojo įvestu metu per trumpą laiką. Galime naudoti ciklą while, kad kartotume tol, kol rankiniu būdu išeisime iš ciklo, naudodami CTRL + D, išsaugodami failo pakeitimus arba CTRL + C, kad išvengtume įrašymo į failą. Naudojame skaitymo komandą, norėdami įvesti tekstą iš komandinės eilutės ir išanalizuoti jį į failą.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim write-wh.sh 

#! /bin/bash

failas=wh.txt
echo Įveskite turinį į failą $file
skaitant eilutę
daryti
echo $line>> $failas
padaryta

Nors ciklas „Linux“.

Taigi iš aukščiau pateikto pavyzdžio galėjome įvesti tekstą į failą naudodami ciklą ir skaityti komandą. Norėdami išeiti iš ciklo ir išsaugoti failo pakeitimus, naudojame klavišus CTRL+ D, o norėdami išeiti iš ciklo nieko neišsaugodami faile, galime naudoti klavišus CTRL + C. Taigi tekstą iš komandinės eilutės į tekstinį failą įvedame naudodami skaitymo komandą ir ciklą while.

Nutraukite ir tęskite naudojimą, kai ciklas

Pertraukti ir tęsti yra būtini programoje, kuri nagrinėja ciklo teiginius, nes jie kontroliuoja ciklo teiginių srautą be jokių aiškių sąlygų.

Pertraukos teiginys „When Loop“.

Naudojame pertraukos teiginius, kad išeitume iš ciklo nelaukdami, kol ciklo while sąlyga bus įvertinta kaip false. Šis teiginys gali būti naudojamas ciklo bloke. Tai gali būti naudojama norint išeiti iš begalinio ciklo su programine sąlyga ciklo viduje ir taip išlaikyti kilpos valdymą.

Pavyzdžiui, turime scenarijų, kuris skaičiuojamas nuo 1 ir amžinai. Bet mes galime programiškai išeiti iš ciklo naudodami pertraukos teiginį ciklo turinyje su sąlyga.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash

i=1
tuo metu:
daryti
aidas $i
jei [ $i -eq 20 ]; tada
echo Tai yra ciklo pabaiga
pertrauka
būti
((i++))
padaryta

Pertraukos pareiškimas, kai ciklas sistemoje „Linux“.

Iš scenarijaus ir vykdymo matome, kad galėjome nutraukti arba išeiti iš begalinės kilpos su sąlyginiu sakiniu ir pertraukos sakiniu. Taigi pertraukos sakinys naudojamas norint gauti programos/scenarijaus valdymo srautą iš nors ciklo viduje, kad ištrūktų iš ciklo, ciklo sąlygai neįvertinus į false.

Tęskite teiginį „When Loop“.

Galime naudoti teiginį tęsti, kad padarytume priešingą sakinį break. Jis pereis į ciklo bloko pradžią ir vėl kartosis. Tai gali būti naudojama tam tikroms komandoms praleisti tam tikromis sąlygomis, taigi leidžia pakeisti ciklo srautą.

Pavyzdžiui, jei turime kintamąjį, inicijuotą 1, ir norime rodyti tik skaičius, dalijamus iš penkių, arba tam tikru modeliu pagal sąlygą, galime naudoti teiginius tęsti. Tai leidžia kartoti per kilpą norimu būdu.

Pirmiausia sukuriame tekstinį failą naudodami teksto rengyklę sistemoje „Linux“, šiuo atveju naudojame „vim“ teksto rengyklę.

vim while.sh 

#!/usr/bin/bash

i=1
o [ $i -lt 30 ];
daryti
((i++))
if [[ $(( $i % 5 )) -ne 0 ]];
tada
Tęsti
būti
aidas $i
padaryta

Tęsti teiginį Nors cikle Linux sistemoje

Kaip matome teiginį tęsti, peršoka į bloko pradžią ir pradeda vykdyti komandas, praleisdamas kitas bloko viduje esančias komandas. Ciklas while kartojasi tik pagal reikšmę kintamasis i yra mažesnis nei 30, taigi, jei sąlyga patikrina, ar kintamasis i dalijasi iš 5, o jei ne, kartojame dar kartą naudodami tęsti ir padidiname kintamojo i reikšmę. The kintamasis i atkartojamas tik tuo atveju, jei dalijasi iš 5, todėl sąlyga if įvertinama kaip klaidinga ir mes nesusiduriame su teiginiu tęsti ir nevykdome įprastu ciklo srautu. Tai daroma siekiant išvengti kiekvieno skaičiaus registravimo ir spausdinti tik tuos skaičius, kurie neatitinka šablono ar sąlygos sakinyje if ar kituose sąlyginiuose sakiniuose.

Dažnai užduodami klausimai

1. Kas yra ` while`> kilpa Bash scenarijuje?

A while> kilpa yra valdymo srauto sakinys Bash scenarijuose, leidžiantis tam tikrą kodo bloką vykdyti pakartotinai, kol nurodyta sąlyga yra teisinga. Ciklas yra būdas automatizuoti pasikartojančias užduotis ir yra pagrindinė scenarijų ir programavimo konstrukcija.

2. Kaip veikia ` sintaksė while`> kilpa ieškoti Bash?

Pagrindinė a sintaksė while> kilpa Bash yra tokia:

o [ sąlyga ]
daryti
# Kodas turi būti vykdomas, kol sąlyga yra teisinga
padaryta

` condition`> yra testas, kuris įvyksta prieš kiekvieną ciklo iteraciją. Jei sąlyga yra teisinga, ciklas kodas yra vykdomas. Jei sąlyga klaidinga, ciklas baigiamas, o scenarijus tęsiamas su kita komanda po ` done`> pareiškimas.

3. Koks yra ` vaidmuo (( ... ))`> statyti Bash while> kilpa?

` (( ... ))`> Konstrukcija Bash kalba naudojama aritmetinėms operacijoms atlikti. „A“ kontekste while`> kilpa, ji dažnai naudojama aritmetinėms sąlygoms įvertinti.

Pavyzdžiui: ` ((i <10))> `> patikrina, ar kintamasis ` i`> yra mažesnis nei 10. Tai leidžia naudoti aritmetines išraiškas tiesiogiai ciklo sąlygoje, todėl tai ypač naudinga atliekant skaitinius palyginimus.

4. Kaip sukurti begalinę kilpą naudojant ` while`> Baše?

Begalinis Bash ciklas gali būti sukurtas pateikiant sąlygą, kuri visada vertinama kaip tiesa.

Pavyzdžiui:

o tiesa
daryti
# Begalinės kilpos kodas
padaryta

Arba sąlygoje galite naudoti nenulinę konstantą, pvz ` while [ 1 ]`> , pasiekti tą patį rezultatą. Begalinės kilpos yra naudingos tais atvejais, kai reikalingas nuolatinis vykdymas, kol nenutrūkstama rankiniu būdu.

Išvada

Šiame straipsnyje aptarėme BASH scenarijų, while ciklus, kuris pasirodė esąs universalus įrankis, leidžiantis pakartotinai vykdyti kodo bloką pagal nurodytą sąlygą. Pagrindinė sintaksė apima sąlygos apibrėžimą laužtiniuose skliaustuose, kad būtų galima atlikti lanksčias iteracijas. Straipsnyje nagrinėjamos įvairios while ciklo programos, įskaitant skaitymą iš failų, begalinių ciklų kūrimą, fiksuotas iteracijas, komandinės eilutės argumentų analizavimą ir pertraukos ir tęsimo teiginių naudojimą. Nuo C stiliaus sintaksės iki interaktyvaus failų rašymo, kiekvienas pavyzdys parodo ciklo pritaikomumą tenkinant įvairius scenarijų poreikius. Ši išsami apžvalga pabrėžia while ciklo svarbą BASH scenarijuose, suteikiant tvirtą valdomo pasikartojimo ir efektyvaus kodo vykdymo mechanizmą.