Tsükkel on juhtimisjuhend, mis võimaldab korrata programmikoodi täitmist teatud arv kordi. Iga üksikut juhiste täitmist tsükli kehas nimetatakse iteratsiooniks.

samas silmus

Silmuse süntaks:

Sulgudes olevat avaldist nimetatakse tsükli täitmise tingimuseks või lühendatult tingimuseks. Esiteks arvutatakse välja avaldise väärtus. Saadud väärtus teisendatakse vajaduse korral kaudselt Boole'i ​​tüübiks. Kui avaldise hindamise tulemus on tõene , siis täidetakse tsükli kehas asuv käsk, seejärel viiakse juhtimine üle tsükli algusesse ja tingimust hinnatakse uuesti. Kui avaldise hindamise tulemus on väärtus vale, lõpetab tõlk tsükli ja jätkab tsüklile järgneva käsu täitmisega. Seega täidab tõlk tsükli kehas asuva koodi ikka ja jälle seni, kuni tingimus jääb tõeseks:

Var i = 0; kuni ma< 3) { // Выполнять код, пока значение переменной i меньше 3 alert("i: " + i); i++; // Увеличиваем значение переменной i }

do-while silmus

Do-while tsükli süntaks:

Do-while tsükkel sarnaneb while-tsükliga, välja arvatud see, et tsükli tingimust kontrollitakse pärast esimest iteratsiooni, mitte enne seda, ja tsükkel lõpeb semikooloniga. Kuna tingimust kontrollitakse pärast iteratsiooni, käivitatakse do-while tsükli kehas olev kood alati vähemalt üks kord:

Muutuste arv = 0; do ( document.write(count + " "); count++; ) while(count< 5); Попробовать »

See tsükkel võib olla kasulik, kui tsükli kehas olevat koodi tuleb käivitada vähemalt üks kord, olenemata täitmistingimustest.

silmuse jaoks

Silmuse süntaksi jaoks:

For silmus sisaldab kolme semikooloniga eraldatud avaldist. Nendel kolmel väljendil on järgmine täitmisjärjekord:

Esimest avaldist hinnatakse alati ainult üks kord – enne esimest iteratsiooni. Seetõttu on tavaliselt esimene avaldis muutuja määratlus, mida kasutatakse tsükli täitmise tingimuses loendurina.

Teine avaldis määratleb tsükli täitmise tingimuse. See arvutatakse enne iga iteratsiooni ja määrab, kas tsükli põhiosa täidetakse. Kui avaldise hindamise tulemus on tõene, programmi kood täidetakse silmuse kehas. Kui tagastatakse false, siis tsükkel lõpeb ja juhtimine liigub tsükli järel järgmise käsu juurde. Tingimuse esmakordsel kontrollimisel osutub see valeks, tsükli kehas olevat koodi ei käivitata isegi üks kord.

Pärast iga iteratsiooni hinnatakse kolmandat avaldist. Tavaliselt kasutatakse seda tsükli seisundi testimiseks kasutatava muutuja väärtuse muutmiseks.

Silmuse näide:

For (var count = 0; count< 5; count++) document.write(count + " "); Попробовать »

Nagu näitest näha, silmuse jaoks Erinevalt teistest tsüklitest võimaldab see tsükliga seotud koodi rühmitada ühte kohta.

Mis tahes avaldis for-tsüklis võib puududa, kuid semikoolonid ise peavad olema olemas, muidu süntaksi viga. Kui teine ​​avaldis puudub, kestab tsükkel igavesti.

Var i = 0; for(;i< 4; i++) ... var i = 0; for (; i < 4;) ... for (var i = 1; /* нет условия */ ; i++) ... // Это эквивалентно следующему коду for (var i = 1; true; i++) ...

Ühe avaldise asemel saate määrata mitu avaldist, eraldades need komadega.

// ei käivitata, kuna tingimuse kontrolli viimane avaldis on väär (i = 1; i< 4, false; i++) ... for (var i = 1, j = 5; i , mis võimaldab valida mitu üksust). Silmus for deklareerib muutuja i ja määrab selle väärtuseks 0. Samuti kontrollib see, et i oleks väiksem kui elemendi elementide arv, käivitab if-lause ja suurendab i-d ühe võrra pärast iga tsükli läbimist.

Valige mõned muusikažanrid ja klõpsake allolevat nuppu: R&B Jazz Blues New Age Classical Opera

funktsioon howMany(selectObject) ( var numberSelected = 0; for (var i = 0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected) { numberSelected++; } } return numberSelected; } var btn = document.getElementById("btn"); btn.addEventListener("click", function(){ alert("Выбрано элементов: " + howMany(document.selectForm.musicTypes)) });

do...when loop

Do...while tsükkel kordub seni, kuni antud tingimus on tõene. Do...while avaldus näeb välja selline:

Tee väljendeid while(tingimus);

avaldisi täidetakse seni, kuni tingimus on tõene. Mitme avaldise kasutamiseks kasutage nende rühmitamiseks plokk-avaldist ( ... ). Kui tingimus on tõene, täidetakse avaldised uuesti. Iga läbimise lõpus kontrollitakse seisukorda. Kui tingimus on väär, peatatakse täitmine ja juhtimine viiakse üle avaldisele pärast do...while .

Näide

Järgmises näites käivitatakse do-silmus vähemalt 1 kord ja see käivitatakse uuesti seni, kuni i on väiksem kui 5.

Tehke ( i += 1; console.log(i); ) while (i< 5);

samas silmus

While-silmus täidab avaldisi seni, kuni tingimus on tõene. See näeb välja selline:

Kuigi (tingimuse) väljendid

Kui tingimus muutub vääraks, lõpetavad tsükli avaldised täitmise ja juhtimine läheb üle tsüklile järgnevale avaldisele.

Enne tsüklis olevate avaldiste täitmist kontrollitakse tingimuse tõesust. Kui tingimus on tõene, käivitatakse avaldised ja seejärel testitakse tingimust uuesti. Kui tingimus on väär, peatatakse täitmine ja juhtimine liigub mõne aja pärast avaldisele.

Mitme avaldise kasutamiseks kasutage nende rühmitamiseks avaldiseplokki ( ... ).

Näide 1

Järgmine while tsükkel jookseb seni, kuni n on väiksem kui kolm:

Var n = 0; var x = 0; samas (n< 3) { n++; x += n; }

Iga iteratsiooniga suurendab tsükkel n-i ja lisab selle väärtuse x-le. Seetõttu saavad x ja n järgmised väärtused:

• Pärast esimest läbimist: n = 1 ja x = 1
• Pärast teist: n = 2 ja x = 3
• Pärast kolmandat läbimist: n = 3 ja x = 6

Pärast kolmandat läbimist tingimus n< 3 становится ложным, поэтому цикл прерывается.

Näide 2

Vältima lõputud silmused. Veenduge, et silmuse tingimus muutub lõpuks valeks; vastasel juhul ei katke tsükkel kunagi. Järgmise while-tsükli avaldised töötavad igavesti, sest tingimus ei muutu kunagi valeks:

While (true) (console.log("Tere, maailm"); )

Silt

Silt on identifikaatoriga avaldus, mis võimaldab viidata mõnele kohale oma programmis. Näiteks saate tsükli tähistamiseks kasutada silti ja seejärel kasutada katkestus- või jätkamislauseid, mis näitavad, kas programm peaks tsükli katkestama või jätkama selle täitmist.

Sildi süntaks on järgmine:

Silt: operaator

Tähendus sildid võib olla mis tahes kehtiv JavaScripti identifikaator, mis ei ole reserveeritud sõna. Operaator , sildi järel määratud avaldis võib olla mis tahes avaldis.

Näide

Selles näites tähistab markLoop ajasilmust.

MarkLoop: while (theMark == true) (doSomething(); )

murda

Kasutage katkestuslauset tsükli katkestamiseks, juhtelemendi muutmiseks või koos sildilausega.

• Kui kasutate pausi ilma sildita, läheb see katki samas silmuseid, do-while ja for või lülitab juhtimise kohe järgmisele avaldisele.
• Kui kasutate murdmist märgiga, katkestab see spetsiaalselt märgitud väljendi.

Operaatori süntaks võib olla:

murda;

murda Silt;

Süntaksi esimene vorm katkestab tsükli täielikult või vahetab juhtimist; teine ​​katkestab spetsiaalselt määratud väljendi.

Näide 1

Järgmine näide itereerib massiivi elemente, kuni leiab elemendi, mille väärtus on theValue:

Kui (i = 0; i< a.length; i++) { if (a[i] == theValue) { break; } }

Näide 2: Sildi katkestus var x = 0; var z = 0 labelCancelLoops: while (true) (console.log("Väline tsükkel: " + x); x += 1; z = 1; while (true) (console.log("Sisemine tsükkel: " + z) ; z += 1; if (z === 10 && x === 10) ( katke silt TühistaLoops; ) else if (z === 10) ( break; ) ) ) jätka

Lauset Jätka kasutatakse sammu võrra edasi liikumiseks samas , do-while , tsüklite jaoks või sildile hüppamiseks.

• Kui kasutate jätkamist ilma sildita, katkestab see tsüklite while , do-while ja for praeguse iteratsiooni ning jätkab tsüklit järgmisest iteratsioonist. Erinevalt pausist ei katkesta jätkamine tsükli täitmist täielikult. Kuigi tsüklis hüppab see tingimusele. Ja see suurendab sammu.
• Kui kasutate jätkamist sildiga, rakendatakse see selle sildiga tsüklile.

Jätkamise süntaks võib välja näha järgmine:

jätkata;

jätka Silt ;

Näide 1

Järgmine näide näitab while-tsüklit jätkulausega, mis käivitub, kui i väärtus on 3. Seega saab n väärtused 1, 3, 7 ja 12.

Var i = 0; var n = 0; kuni ma< 5) { i++; if (i == 3) { continue; } n += i; }

Näide 2

Väljend märgitud checkiandj sisaldab väljendit märgitud checkj. Jätkamise korral katkestab programm praeguse iteratsiooni checkj ja alustab järgmist iteratsiooni. Iga kord, kui kohtate, jätkake checkj jätkab järgmise iteratsiooniga seni, kuni tingimus tagastab väärtuse false . Kui false tagastatakse pärast jaotuse ülejäänud osa arvutamist checkiandj, checkiandj jätkab järgmise iteratsiooniga seni, kuni selle tingimus tagastab vale. Kui tagastatakse false, jätkab programm täitmist avaldisega pärast checkiandj.

Kui jätkamine on märgitud checkiandj, võib programm jätkuda märgi algusest checkiandj.

Checkiandj: while (st< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( jätka checkj; ) console.log(j + "paaris."); ) console.log("i = " + i); console.log("j = " + j); )

jaoks...sisse

Lause for...in itereerib läbi objekti kõik loendatavad omadused. JavaScript käivitab iga jaoks määratud avaldised lahusvara. For...in tsükkel näeb välja selline:

For (objektis muutuv) (avaldised)

Näide

Järgmine funktsioon võtab argumendiks objekti ja selle nime. Seejärel itereerib see läbi kõik objekti omadused ja tagastab stringi, mis sisaldab atribuutide nimesid ja nende väärtusi.

Funktsioon dump_props(obj, obj_name) ( var tulemus = ""; jaoks (var i objektis obj) ( tulemus += objekti_nimi + "." + i + " = " + obj[i] + "
"; ) tulemus += ""; tagasta tulemus; )

Margi ja mudeli omadustega autoobjekti puhul tulemus teeb:

Car.make = Fordi auto.mudel = Mustang

Näide nr 2

Väärtuse saate kuvada ka võtmega:

Olgu obj = (mudel: "AUDI A8", aasta: "2019", värv: "pruun") for (võti objektis obj) ( console.log(`$(key) = $(obj)`); ) // mudel = AUDI A8 // aasta = 2019 // värv = pruun

Massiivid

Kuigi massiivi kõigi elementide itereerimiseks on ahvatlev kasutada for...in, tagastab see operaator lisaks numbrilistele indeksitele ka kasutaja määratud atribuutide nimed. Seega on parem kasutada massiividega suhtlemisel numbriliste indeksite jaoks standardit for, kuna lause for...in läbib konkreetne kasutaja Lisaks massiivi elementidele, kui muudate massiivi, näiteks lisate atribuute ja meetodeid.

jaoks ( muutuv kohta objektiks) { väljendid}

Järgmine näide näitab erinevust for...of ja for... in silmuste vahel. Kui for... iterates atribuutide nimede üle, siis for... of iterates atribuutide väärtuste üle:

Olgu arr = ; arr.foo = "tere"; for (let i in arr) ( console.log(i); // prindib "0", "1", "2", "foo" ) for (let i of arr) ( console.log(i); / / väljastab "3", "5", "7")

Viimane uuendus: 08.04.2018

Silmused võimaldavad toimingut sooritada mitu korda olenevalt teatud tingimustest. JavaScriptil on järgmised tüübid tsüklid:

jaoks..in

jaoks..of

samas

teha..samal ajal

silmuse jaoks

For-tsüklil on järgmine formaalne määratlus:

For ([loenduri lähtestamine]; [seisund]; [loenduri muutus])( // toimingud )

Näiteks kasutame massiivi elementide itereerimiseks tsüklit for:

Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var i = 0; i = 0; i--)( console.log(inimesed[i]); )

IN sel juhul massiiv väljastatakse lõpust ja massiiv itereeritakse i = 3 kuni i = 0.

jaoks..in

For..in silmus on loodud massiivide ja objektide itereerimiseks. Selle ametlik määratlus on:

For (massiivi indeks) ( // toimingud )

Näiteks korrakem massiivi elemente:

Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var index in people)( console.log(people); )

Loop for...of

Silmus for...of sarnaneb tsükliga for...in ja on loodud kogude, näiteks massiivide, kordamiseks:

Laske kasutajatel = ["Tom", "Bob", "Sam"]; for(kasutajate väärtus) console.log(val);

Praegune itereeritav koguelement asetatakse muutujasse val, mille väärtus prinditakse seejärel konsooli.

samas silmus

Silmus while töötab seni, kuni mõni tingimus on tõene. Selle ametlik määratlus on:

Kuigi(seisund)( // toimingud )

Jällegi kuvame massiivi elemendid, kasutades samal ajal:

Var people = ["Tom", "Alice", "Bob", "Sam"]; var indeks = 0; while(indeks< people.length){ console.log(people); index++; }

Siin olev while-tsükkel käivitatakse seni, kuni indeksi väärtus muutub pikkusega võrdne massiivi.

teha..samal ajal

Do-tsüklis käivitatakse esmalt tsükli kood ja seejärel kontrollitakse while-lause tingimust. Ja kuni see tingimus on tõsi, tsükkel kordub. Näiteks:

Var x = 1; do( console.log(x * x); x++; )while(x< 10)

Siin käitatakse tsüklikoodi 9 korda, kuni x-ist saab 10. Do-tsükkel garanteerib, et toiminguid teostatakse vähemalt üks kord, isegi kui while-lause tingimus ei ole tõene.

Jätkake ja katkestage laused

Mõnikord on vaja tsüklist väljuda enne selle lõppemist. Sel juhul saame kasutada katkestuslauset:

< array.length; i++) { if (array[i] >10) vaheaeg; document.write(massiiv[i] + "
"); }

See tsükkel itereerib läbi kõik massiivi elemendid, kuid viimaseid nelja elementi brauseris ei kuvata, kuna test if (massiiv[i] > 10) katkestab massiivi itereerimisel tsükli katkestuslausega element 12.

Kui me peame lihtsalt iteratsiooni vahele jätma, kuid mitte tsüklist väljuma, võime kasutada jätkulauset:

Muutuja massiiv = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; jaoks (var i = 0; i< array.length; i++) { if (array[i] >10) jätkata; document.write(massiiv[i] + "
"); }

Sel juhul, kui programm leiab massiivis arvu, mis on suurem kui 10, siis seda numbrit brauseris ei kuvata.

Väga sageli on vaja mõnda programmi osa mitu korda käivitada. Muidugi saate seda lihtsalt teha: kopeerige ja kleepige vajalik arv kordi. See on aga absurdne, eriti kui tegevust tuleb sooritada näiteks 1000 korda. Seetõttu on olemas nn tsüklid, mis on olemas enamikus programmeerimiskeeltes. Ja ma räägin teile neist.

Sisaldab kindlat koodi, mida keritakse mitu korda. Silmuseid on mitut tüüpi: for, while ja do-while.

Alustame kõige esimesest tsüklist (ja kõige populaarsemast) - for-tsüklist. Selle tsükli üldine välimus on järgmine:

For (iteratsiooni_muutuja = esialgne_väärtus; tingimus; action_after_each_iteration) (
//programmi kood
}

Las ma kommenteerin siin kirjutatut. Esimene tuleb - iteratsiooni muutuja. See on iteratsiooni tavaline muutuja nimi. Järgmine tuleb Algne väärtus. Tegelikult nimi räägib enda eest. Järgmiseks tuleb tingimus, mille täitmisel (st tõene tagastatakse), käivitatakse tsükkel veel üks kord ja lõpuks toiming, mis sooritatakse pärast iga iteratsiooni. Tavaliselt on see iteratsiooni muutuja muudatus.

Kirjutame lihtsa skripti, mis kuvab tsükli iteratsioonide arvu:

Kui (i = 0; i< 100; i++)
document.write(i + " ");

Siin oleme määratlenud iteratsiooni muutuja (nimetatakse i), millele on omistatud väärtus 0. Järgmisena kontrollitakse seisundit: i< 100 . Kui see täidetakse, siis käivitatakse tsükli üks iteratsioon. Pärast iga iteratsiooni lõppu i++(st muutuja i suurendamine 1 võrra). Tingimust kontrollitakse uuesti ja kui see on tõene, tehakse uus iteratsioon. Ja nii edasi kuni tingimuseni i< 100 ei muutu valeks. Ilmselgelt on see vale alles pärast 100 iteratsiooni. Seega käivitatakse see tsükkel 100 korda, mida näeme selle skripti käivitamisel. Ja veel üks asi. Kuna meil on siin teostatud ainult üks operaator (document.write() ), siis kohalolu lokkis traksid ei ole vajalik. Kui tsüklis töötab 2 või enam operaatorit, peate need installima.

Räägime nüüd JavaScripti teist tüüpi silmustest – while. Põhimõtteliselt on silmus väga sarnane for-tsükliga (kuigi kõik tsüklid on sarnased). Aga siin üldine vorm teine:

Kuigi (seisund) (
//programmi kood
}

Nagu näete, ei ole iteratsiooni jaoks muutujat ega toiminguid pärast iteratsiooni. Sellest järeldub järeldus: tsüklist väljumiseks on vaja seda teha tsüklis endas, et " tingimus" on muutunud valeks. Kui seda ei tehta, tekib silmus ja teie skript hangub.

Rakendame sama ülesande nagu varemgi, kuid kasutades while-tsüklit.

Var i = 0;
kuni ma< 100) {
i++;
document.write(i + " ");
}

Enne tsükli käivitamist lõime muutuja i, millele määrati algväärtus. Seejärel kontrollitakse enne tsükli käivitamist tingimust ja kui see on tõene, siis käivitatakse tsükli iteratsioon, milles suurendame muutujat iteratsiooni jaoks (muidu tekib tsükkel). Ja me kuvame selle muutuja.

Ja lõpuks on JavaScripti viimast tüüpi silmused do-while silmus. Süntaks on:

Do(
//programmi kood
) samas (seisund)

Väga sarnane while-tsükliga, kuid seal on ainult üks asi, kuid see on väga põhimõtteline erinevus. Kui while-tsükkel kontrollib esmalt tingimust ja seejärel kordab või mitte. Silmus do-while kordub esmalt ja alles seejärel kontrollib tingimust. Ja kui see on vale, väljub see tsüklist. Teisisõnu, olenemata tingimusest, täidetakse see silmus vähemalt üks kord. Ma arvan seda see kood See on üleliigne, kuid siiski.

Var i = 0;
teha (
i++;
document.write(i + " ");
) kuni ma< 100)

Ma ei selgita koodi, olen kindel, et saate sellest aru ilma minuta. Nii et ma lähen parem kahe huvitava väite juurde: katkesta ja jätka.

Alustame vaheajast. See operaator võimaldab varakult tsüklist välja hüpata. Kirjutame järgmise koodi:

Kui (i = 0; i< 100; i++) {
if (i == 50) murda;
document.write(i + " ");
}

Saate seda skripti käivitada ja leida, et prinditakse ainult numbrid kuni 49, kuna millal i = 50 Loop katkes tänu break-lausele.

Nüüd räägin jätkajast. See operaator võimaldab teil liikuda tsükli järgmisele iteratsioonile. Et mitte siin liiga palju kirjeldada, on parem näidata kohe näidet:

Kui (i = 0; i< 100; i++) {
kui (i == 50) jätka;
document.write(i + " ");
}

Kui käivitate selle skripti, näete, et number 50 on puudu. See juhtus seetõttu, et millal i = 50, liigume edasi tsükli järgmise iteratsiooni juurde, enne mida i suureneb 1 võrra ja võrdub 51.-ga.

Tundub, et see on kõik, millest ma kirjutada tahtsin JavaScripti tsüklid. Loodan, et kõik on teile selgeks saanud. Võite ka ise probleemi välja mõelda ja lahendada. Sellest saab suurepärane treening.

|

Kuna while ja do...while on tingimuslikud, täidetakse need siis, kui antud lause väärtus on tõene. For avaldus põhineb samuti tingimustel, kuid annab lisafunktsioone, näiteks tsükliloendur, mis võimaldab eelnevalt määrata tsükli iteratsioonide arvu.

See õpetus õpetab teile, kuidas kasutada tsüklites for, for...of ja for..., mis on JavaScripti programmeerimise lahutamatud elemendid.

silmuste jaoks

For silmus võib koodiploki korduvalt käivitamiseks kasutada kuni kolme valikulist avaldist.

Vaatame tsükli süntaksit.

for (initsialiseerimine; tingimus; lõplik avaldis) (
// käivitatav kood
}

• Initsialiseerimine (kui see on määratud) käivitab loenduri ja deklareerib muutujad.
• Järgmisena töödeldakse tingimust. Kui see on tõene, käivitab programm järgmise koodi; kui see on vale, siis silmus katkeb.
• Seejärel töödeldakse käivitamist vajavat koodi.
• Kui lõplik avaldis on määratud, värskendatakse seda, misjärel naaseb tsükkel tingimuse töötlemise juurde.

Et mõista, kuidas see toimib, vaatame põhinäidet.

jaoks (olgu i = 0; i< 4; i++) {
// Iga iteratsiooni printimine konsooli
console.log(i);
}

Kui käivitate selle koodi, saate järgmise tulemuse:

0
1
2
3

Ülaltoodud näites algab tsükkel for muutujaga let i = 0, mis alustab tsüklit väärtusega 0. Tingimuseks tsüklis on i< 4, а это означает, что до тех пор, пока значение i меньше 4, цикл будет продолжать работу. Финальное выражение i++ определяет счетчик для каждой итерации цикла. console.log(i) выводит числа, начиная с 0, и останавливается, как только i равняется 4.

Ilma tsüklita oleks sama kood:

// Määra algmuutujaks 0
olgu i = 0;
// Muutuja käsitsi suurendamine 1 võrra neli korda
console.log(i++);
console.log(i++);
console.log(i++);
console.log(i++);

Ilma tsüklita koosneb koodiplokk rohkem read. Numbrite arvu suurendamiseks peaksime koodile lisama veelgi rohkem ridu.

Vaatame tsükli iga väljendit.

Initsialiseerimine

Silmuse esimene avaldis on initsialiseerimine.

See deklareerib muutuja i, kasutades märksõna let (võite kasutada ka märksõna var) ja annab sellele väärtuse 0. Silmuses võib kasutada mis tahes muutujate nimesid, kuid muutuja i on seotud sõnaga "iteratsioon" ja see ei koorma koodi üle.

Seisund

Nagu while ja do...whi silmustel on for silmustel tavaliselt tingimus. IN selles näites See:

See tähendab, et avaldis on tõene seni, kuni i väärtus on väiksem kui 4.

Lõplik väljend

See on avaldis, mis täidetakse iga tsükli lõpus. Kõige sagedamini kasutatakse seda muutuja väärtuse suurendamiseks või vähendamiseks, kuid seda saab kasutada ka muudel eesmärkidel.

Selles näites suurendab tsükkel muutujat ühe võrra. Avaldis i++ teeb sama, mis i = i + 1.

Erinevalt algusest ja tingimusest ei lõpe lõppavaldis semikooloniga.

Loop Body

Nüüd teate kõiki for-tsükli komponente. Vaatame uuesti koodi.

// For-lause initsialiseerimine 5 iteratsiooniga
jaoks (olgu i = 0; i< 4; i++) {
console.log(i);
}

Esimene avaldis täpsustab algne väärtus muutuja (0), teine ​​määrab tingimuse (silmus käivitatakse, kui i on väiksem kui 4) ja kolmas määrab iga iteratsiooni sammu (sel juhul suureneb väärtus 1 võrra).

Konsool väljastab väärtused: 0, 1, 2 ja 3. Seejärel silmus katkeb.

Valikulised avaldised

Kõik silmuse avaldised on valikulised. Näiteks võite kirjutada sama tsükli jaoks, kuid jätta lähtestamise vahele ja lähtestada muutuja väljaspool tsüklit.

olgu i = 0;
// Initsialiseeri tsükkel
for(; i< 4; i++) {
console.log(i);
}
0
1
2
3

Sel juhul näitab esimene semikoolon, et algus on puudu.

Märkus. Isegi kui te ühtki avaldist ei kasuta, peate lisama semikooloni, vastasel juhul tõlgendatakse tsüklit valesti.

Samuti saate näiteks tingimuse tsüklist eemaldada. Silmuse peatamiseks, kui muutuja väärtus muutub suuremaks kui 3, kasutage if ja break.

// Muutuja deklareerimine väljaspool tsüklit
olgu i = 0;
//Jäta välja lähtestamine ja tingimus
jaoks (; ; i++) (
kui (i > 3) (
murda;
}
console.log(i);
}
0
1
2
3

Tähtis! Tingimuseta silmustel peate kasutama pausi operaator. Vastasel juhul ei saa tsüklit katkestada (sellist silmust nimetatakse lõputuks) ja see põhjustab brauseri krahhi.

Samuti saate tsüklist eemaldada lõpliku avaldise. Sammu saab määrata tsüklikoodi lõpus. Sel juhul peate jätma mõlemad ";" märgid sulgudesse, vastasel juhul tsükkel ei tööta.

// Muutuja deklareerimine väljaspool tsüklit
olgu i = 0;
//Jäta kõik väited välja
jaoks (; ;) (
kui (i > 3) (
murda;
}
console.log(i);
i++;
}
0
1
2
3

Nagu näete, toodavad silmusavaldised kõige kokkuvõtlikuma ja loetavama koodi.

Massiivide muutmine

For tsüklit saab kasutada massiivide muutmiseks.

Järgmine näide näitab, kuidas luua tühi massiiv ja täita see tsükliloenduri abil muutujatega. Looge fail modifyArray.js ja lisage sellele järgmine kood:

// Initsialiseeri tühi massiiv
olgu arrayExample = ;
// Initsialiseeri tsükkel 3 korda käitamiseks
jaoks (olgu i = 0; i< 3; i++) {
// Värskendage massiivi muutuva väärtusega
massiivExample.push(i);
konsool.log(massiivNäide);
}

Käivitage programm. See väljastab:

[ 0 ]
[ 0, 1 ]
[ 0, 1, 2 ]

Antud tsüklit teostatakse kuni i< 3 перестанет быть истинным. Массив arrayExample выводится в консоль в конце каждой итерации. Так вы можете увидеть, как массив пополняется новыми значениями.

Massiivi pikkus

Mõnikord tuleb tsüklit mitu korda täita, kuid vajaliku iteratsioonide arvu määramine on keeruline. Selle asemel, et deklareerida iteratsioonide arvu, nagu eelmistes näidetes, võite kasutada atribuuti pikkus, et panna tsükkel jooksma nii palju kordi, kui massiivi elemente on.

// Massiivi deklareerimine 3 elemendiga
lase kala = [ "lest", "lõhe", "haug" ];
//Initsialiseerige tsükli jaoks, mis töötab massiivi kogupikkuses
jaoks (olgu i = 0; i< fish.length; i++) {
// Printige iga üksus konsooli
console.log(kala[i]);
}

Selline programm annab tulemuse:

lest
lõhe
haug

See tsükkel itereerib läbi iga massiivi indeksi, kasutades fish[i]. See viib dünaamiline värskendus indeks igal iteratsioonil.