Forțați ieșirea din buclă în javascript. Despre funcțiile de reducere și filtrare

Scopul principal al JavaScript-ului while este de a rula în mod repetat o anumită bucată de cod, iar și iar. Este foarte asemănător cu o buclă for cu o diferență importantă. Permiteți-mi să-mi iau puțin din timp pentru a explica diferența dintre aceste două tipuri de cicluri.

Care este diferența dintre buclele while și for?

Diferența dintre aceste bucle este modul în care opresc executarea unei porțiuni de cod.

Bucla for execută un număr stabilit de iterații. Știm exact de câte ori bucla va executa fragmentul de cod conținut în corpul său.

În timp, totul se întâmplă diferit. O buclă JavaScript while rulează atâta timp cât o anumită condiție este adevărată. Odată ce condiția devine falsă, atunci bucla while se termină.

Motivul pentru care aceste bucle sunt diferite este că nu putem ști neapărat dinainte când o anumită condiție nu va mai fi adevărată. Prin urmare, nu putem prezice câte iterații ale buclei while se vor finaliza înainte de a se întrerupe.

Avantaje și dezavantaje ale buclei while

Permiteți-mi să încep prin a vedea singurul dezavantaj major al buclei while. Poate funcționa pentru totdeauna!

Dacă vă aflați într-o situație în care bucla while continuă să se execute pe termen nelimitat, programul dvs. se va bloca (sau se va bloca). Apoi trebuie să închideți browserul pentru a întrerupe execuția codului JavaScript.

Ar trebui să rețin că bucla while negestionată de JavaScript, de obicei, nu rulează pentru totdeauna. Pentru că, în calitate de programatori, avem întotdeauna responsabilitatea de a ne asigura că la un moment dat starea buclei noastre while devine falsă.

Acum, în ceea ce privește „avantajele” - acestea sunt foarte evidente. While va rula continuu atâta timp cât condiția este îndeplinită. Un exemplu de utilizare a unei bucle while este acela de a cere utilizatorului să introducă date. Bucla vă va solicita să introduceți date din nou și din nou până când utilizatorul introduce datele corecte.

Sintaxa buclei while

Sintaxa buclelor for și while este foarte asemănătoare.

Trebuie să utilizați cuvântul cheie while și, de asemenea, să definiți o condiție în care va fi executată bucla. Ca și alte structuri de control, bucla while își definește domeniul de aplicare.

Iată cum ar trebui să arate codul:

while () ( // introduceți aici codul care ar trebui să fie executat într-o buclă)

Cea mai grea parte este să determinați ce condiție sau condiții trebuie plasate în buclă pentru ca aceasta să funcționeze corect.

Amintiți-vă că atâta timp cât condiția este adevărată, bucla va continua să ruleze. Să ne uităm la un exemplu de utilizare în timp ce în JavaScript.

Exemplu de buclă while

Să presupunem că vrem să cerem utilizatorului să introducă un număr între 1 și 10. Dar ce se întâmplă dacă introduce un număr greșit?

În acest caz, trebuie să-i cerem să introducă din nou valoarea, și să verificăm dacă condiția este îndeplinită (dacă este introdus un număr între 1 și 10).

Acesta este un caz în care o buclă for ar eșua lamentabil. Pentru că nu putem ști dinainte de câte ori va trebui să cerem utilizatorului să introducă numărul corect. În acest caz, bucla while ne vine în ajutor.

Iată cum ar putea arăta codul nostru:

var theNumber = prompt("Vă rugăm să introduceți un număr între 1 și 10."); în timp ce (Numărul< 1 || theNumber >10 || isNaN(theNumber)) ( theNumber = prompt("Valoare introdusă nevalidă, introduceți un număr între 1 și 10!"); ) alert("Excelent! Ați introdus un număr: " + theNumber);

Este demn de remarcat faptul că în exemplul de mai sus avem trei condiții separate într-o buclă while JavaScript.

Aceste trei condiții sunt: ​​numărul 10 || esteNaN(numărul) . Ele indică următoarele:

• DACĂNumărul este mai mic decât 1, SAU;
• DACĂNumărul este mai mare decât 10, SAU;
• DACĂ Numărul NU este un număr, atunci continuați bucla.

Deoarece folosim operatorul SAU (||) între toate condițiile, aceasta înseamnă că dacă oricare dintre condiții este adevărată, atunci condiția generală a buclei while va fi evaluată la adevărată și bucla va continua să se execute.

Numai dacă toate cele trei condiții sunt evaluate ca false, starea generală a buclei while va fi evaluată ca falsă și se va opri.

Concluzie

JavaScript while loop este singura buclă reală în limbajele de programare. for este doar o variație specială a buclei while.

Acesta este un caz în care puteți recrea singur o buclă for folosind sintaxa buclei while, urmăriți și învățați:

var counter = 0; în timp ce (contor< 10) { counter = counter + 1; console.log("The counter is currently at: " + counter); }

Codul va fi repetat de exact 10 ori, nici mai mult, nici mai puțin. Exact așa funcționează bucla for.

Nu trebuie să vă fie teamă să utilizați JavaScript în timp ce . Pentru că fără el, multe aplicații pur și simplu nu ar funcționa corect!

Sper că v-a plăcut acest articol.

Traducerea articolului „While Loop in JavaScript” a fost pregătită de echipa prietenoasă a proiectului.

Rău Bun

Ultima actualizare: 04/08/2018

Buclele vă permit să efectuați o acțiune de mai multe ori în funcție de anumite condiții. JavaScript are următoarele tipuri de bucle:

pentru..in

pentru..de

in timp ce

face în timp ce

pentru buclă

Bucla for are următoarea definiție formală:

Pentru ([inițializarea contorului]; [condiția]; [modificarea contorului])( // acțiuni )

De exemplu, folosim o buclă for pentru a itera elementele unui tablou:

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

În acest caz, matricea este scoasă de la sfârșit, iar matricea este iterată de la i = 3 la i = 0.

pentru..in

Bucla for..in este concepută pentru a itera prin matrice și obiecte. Definiția sa formală este:

Pentru (index în matrice) ( // acțiuni )

De exemplu, să repetăm ​​elementele matricei:

Oameni Var = ["Tom", "Alice", "Bob", "Sam"]; pentru(indexul var în oameni)( console.log(oameni); )

Buclă pentru...de

Bucla for...of este similară cu bucla for...in și este concepută pentru a itera prin colecții, cum ar fi matrice:

Permite utilizatorilor = [„Tom”, „Bob”, „Sam”]; for(lasa valul utilizatorilor) console.log(val);

Elementul de colecție curent care se repetă este plasat în variabila val, a cărei valoare este apoi imprimată pe consolă.

buclă while

Bucla while rulează atâta timp cât o condiție este adevărată. Definiția sa formală este:

În timp ce(condiție)( // acțiuni )

Din nou, vom afișa elementele matricei folosind while:

Oameni Var = ["Tom", "Alice", "Bob", "Sam"]; var index = 0; în timp ce (index< people.length){ console.log(people); index++; }

Bucla while aici se va executa până când valoarea indexului este egală cu lungimea matricei.

face în timp ce

Într-o buclă do, codul buclei este mai întâi executat, iar apoi condiția din instrucțiunea while este verificată. Și atâta timp cât această condiție este adevărată, ciclul se repetă. De exemplu:

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

Aici codul buclei va rula de 9 ori până când x devine 10. Bucla do garantează că acțiunile vor fi executate cel puțin o dată, chiar dacă condiția din instrucțiunea while nu este adevărată.

Continuați și întrerupeți declarațiile

Uneori este necesar să părăsiți o buclă înainte de a se finaliza. În acest caz, putem folosi instrucțiunea break:

< array.length; i++) { if (array[i] >10) pauză; document.write(matrice[i] + "
"); }

Această buclă iterează prin toate elementele matricei, dar ultimele patru elemente nu vor fi afișate în browser, deoarece testul if (array[i] > 10) va întrerupe bucla cu o instrucțiune break atunci când iterarea prin matrice ajunge. elementul 12.

Dacă trebuie doar să sărim iterația, dar nu să ieșim din buclă, putem folosi instrucțiunea continue:

Var array = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; pentru (var i = 0; i< array.length; i++) { if (array[i] >10) continua; document.write(matrice[i] + "
"); }

În acest caz, dacă programul întâlnește un număr mai mare de 10 în matrice, atunci acest număr nu va fi afișat în browser.

Bucla for este cea mai folosită buclă în JavaScript.

Designul său arată astfel:

Pentru (început; condiție; pas) ( /* corpul buclei */ )

Este foarte simplu. Să ne uităm la un exemplu:

Var i; pentru (i = 1; i

În acest exemplu:

• Începutul buclei: i = 1 (începând de la valoarea i = 1)
• Starea ciclului: i
• Pas de buclă: i++ (la fiecare pas de buclă cresc cu 1)
• Corpul buclei: document.write("

  Numărul pasului ciclului este executat: " + "

  "); (afișează un mesaj pe ecran)

Algoritm pas cu pas pentru executarea acestei bucle for, mai detaliat:

Începutul buclei: variabila i este setată la 1. Această parte a buclei este executată o dată.

Se verifică condiția buclei (i 5) - sfârșitul buclei.

Corpul buclei este executat.

Pasul buclei este executat. În cazul nostru i++. Este întotdeauna executat după corpul buclei.

Reveniți la punctul 2.

Dacă corpul buclei constă dintr-o instrucțiune, atunci bretele (...) nu sunt necesare.

Variabila i nu dispare după terminarea buclei. Continuă să existe și valoarea sa după sfârșitul ciclului va fi egală cu 6.

Să rezumam aceste date într-un nou exemplu:

Var i; pentru (i = 1; i

Aici, bretele nu au fost folosite pentru a crea corpul buclei.

Acolade (...) formează un bloc în JavaScript - acesta este unul dintre constructele limbajului. Adică, dacă există acolade după instrucțiunea bucla for, aceasta înseamnă că handlerul JavaScript trebuie să execute întregul bloc JavaScript.

Similar unui bloc, puteți specifica o funcție într-o buclă for. Iată un exemplu:

Pentru (var i = 1; i

Dar atunci când se declară o funcție, sunt necesare acolade (...). Absența lor va duce la o eroare.

Vă rugăm să rețineți că în această buclă variabila i este declarată la începutul buclei: for ( var i = 1; i

Sari peste piese

În general, începutul ciclului nu trebuie scris:

Var i = 1; pentru(; i

Vedeți, la începutul buclei există doar un punct și virgulă, iar bucla funcționează bine.

De asemenea, puteți elimina pasul:

Var i = 1; pentru(; i

Această buclă for s-a transformat într-un analog al buclei while (de exemplu

Puteți pune o expresie într-o condiție care modifică o variabilă.

Pentru (i = 10; i--;) ( document.write("

Se execută pasul buclei: " + i + ".

"); }

Deoarece interpretul JavaScript se așteaptă să primească o valoare booleană, orice valoare are ca rezultat un tip boolean, așa că atunci când variabila i devine 0 (falsă) ca urmare a următoarei scăderi, bucla se va opri.

Buclă pentru infinit

Da, da, știu că este corect să scrii infinit :)

Deci, bucla va fi nesfârșită dacă condiția este întotdeauna adevărată. Iată un exemplu:

Pentru (var i = 1; i

În acest exemplu, variabila i va scădea și nu va deveni niciodată mai mare de cinci. Bucla va rula pentru totdeauna. Încercați să rulați acest script. Pentru mine, Chrome „s-a pierdut în gânduri” și nu a afișat nimic pe ecran, dar a continuat să gândească și să gândească.

Aveți grijă să evitați crearea accidentală de bucle nesfârșite.

Întreruperea buclei for

Pentru a întrerupe o buclă for, la fel ca pentru a întrerupe orice altă buclă, utilizați comanda break. Când motorul JavaScript întâlnește o comandă de pauză în corpul unei bucle, oprește executarea buclei și începe să execute instrucțiunile de script care urmează buclei. Dacă există.

În exemplul următor, vom opri bucla la a treia iterație (al treilea pas).

Pentru (var i = 1; i

Să complicăm puțin exemplul

Să efectuăm doar 100 de iterații ale buclei infinite.

Var $contor = 1; pentru (var i = 1; i

Următoarea iterație: continua

Comanda continue încheie iterația curentă și începe următoarea.

Directiva continue este „sora mai mică” a directivei break; oprește doar iterația, și nu întreaga buclă.

Pentru (var i = 1; i

Bucla de mai jos folosește continuare pentru a scoate valori impare:

Pentru (var i = 0; i

Desigur, valorile impare pot fi scoase folosind o buclă ca aceasta fără o directivă continue:

Pentru (var i = 0; i

Directivele break/continuare în „?"

Să descriem pe scurt operatorul semnului de întrebare „?”. Este similar cu un construct if.

Design logic:

Dacă (condiție) ( a(); ) else ( b(); )

Funcționează la fel ca și codul cu operatorul „?”.

Condiție? a() : b(); var i = 2; document.write("

Partea 1.

"); dacă (i == 2) document.write("

Condiția a funcționat.

"); else document.write("

Condiția nu a funcționat.

"); document.write("

Partea 2.

"); i == 2 ? document.write("

Condiția a funcționat.

"): document.write("

Condiția nu a funcționat.

");

Deci, este important să nu puteți utiliza pauză/continuare în dreapta operatorului „?”

În JavaScript, constructele sintactice care nu returnează valori sunt interzise să fie folosite în operatorul „?”.

Exemplul de mai jos nu funcționează, conține o eroare:

Pentru (var i = 0; i

Etichete pentru pauză/continuare

Uneori devine necesar să se creeze bucle imbricate. Într-un astfel de caz, în timp ce bucla imbricată rulează, poate fi necesar să opriți bucla părinte sau să opriți iterația buclei părinte. Etichetele sunt folosite pentru aceasta.

Puteți folosi etichete pentru a desemna bucle, apoi utilizați break sau continuați pentru a ieși din buclă sau continuați bucla cu o nouă iterație.

Markerii sunt singura modalitate prin care comenzile de pauză și continuare pot afecta execuția buclei exterioare.

Instrucțiunea de etichetă este utilizată numai împreună cu break sau continuă să ofere o ieșire alternativă dintr-o buclă.

Eticheta are sintaxa „nume:”, numele etichetei trebuie să fie unic. Marcajul este plasat înaintea ciclului, în aceeași linie sau cu o întrerupere de linie.

În mod similar, puteți utiliza directiva break în acest loc. Dar dacă îl folosiți, după cum înțelegeți, execuția ciclurilor se va opri.

Var i, j; metka1: pentru (i = 0; i

JavaScript nu are o declarație goto precum PHP; este posibil să se folosească doar etichete break sau continue.

Etichetele sunt rareori folosite în programarea JavaScript, deoarece se crede că fac codul mai greu de citit și de înțeles. Se recomandă utilizarea funcțiilor la codificare.

Buclele sunt o modalitate simplă de a face ceva de mai multe ori. Acest capitol al Ghidului JavaScript vă va prezenta diferiții operatori disponibili în JavaScript.

Te poți gândi la bucla ca la o versiune computerizată a unui joc în care îi spui cuiva să facă X pași într-o direcție, apoi Y pași în cealaltă; De exemplu, ideea jocului „Mergeți 5 pași spre est” poate fi exprimată ca o buclă:

Var pas; pentru (pas = 0; pas< 5; step++) { // Запускается 5 раз, с шагом от 0 до 4. console.log("Идём 1 шаг на восток"); }

Există multe tipuri diferite de bucle, dar toate fac, în esență, același lucru: repetă unele acțiuni de mai multe ori (nu uitați de timpul de repetiție zero, numărarea în matrice începe de la 0). Ciclurile cu structură diferită oferă modalități diferite de a determina începutul și sfârșitul ciclului. Diverse sarcini de programare au proprii lor operatori de buclă, cu ajutorul cărora pot fi rezolvate mult mai ușor.

Operatori proiectați pentru a organiza bucle în JavaScript:

pentru buclă

Bucla for repetă acțiunile până când apare un eveniment special de terminare a buclei. Declarația for din JavaScript este similară cu instrucțiunea for din Java și C. Declarația for din instrucțiunea este următoarea:

Pentru ([început]; [condiție]; [pas]) expresii

Când este executat, se întâmplă următoarele:

Expresia de pornire este executată, dacă este specificată. Această expresie inițializează de obicei unul sau mai multe contoare, dar sintaxa permite expresiei să fie de orice complexitate. De asemenea, folosit pentru a declara variabile.

Condiția este îndeplinită. Dacă condiția este adevărată, atunci expresiile sunt executate. Dacă este fals, bucla for se întrerupe. Dacă condiția este complet omisă, atunci este considerată adevărată.

Expresiile sunt executate. Pentru a executa mai multe expresii, expresiile bloc ( ... ) sunt folosite pentru a grupa expresii.

Pasul este actualizat dacă există unul, apoi controlul revine la pasul 2.

Exemplu

Următoarea funcție are o buclă for care numără numărul de genuri selectate din lista de defilare (elementul care vă permite să selectați mai multe elemente). Bucla for declară o variabilă i și setează valoarea acesteia la 0. De asemenea, verifică dacă i este mai mic decât numărul de elemente din elementul , execută instrucțiunea if și incrementează i cu unul după fiecare trecere prin buclă.

Selectați câteva genuri de muzică și apoi faceți clic pe butonul de mai jos: R&B Jazz Blues New Age Classical Opera

funcția 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)) });

face...while bucla

Bucla do...while se repetă atâta timp cât condiția dată este adevărată. Declarația do...while arată astfel:

Faceți expresii while(condiție);

expresiile sunt executate atâta timp cât condiția este adevărată. Pentru a utiliza mai multe expresii, utilizați o expresie bloc ( ... ) pentru a le grupa. Dacă condiția este adevărată, expresiile vor fi executate din nou. La sfârșitul fiecărei treceri se verifică starea. Dacă condiția este falsă, execuția este suspendată și controlul este transferat expresiei după do...while .

Exemplu

În exemplul următor, bucla do va fi executată de cel puțin o dată și va rula din nou atâta timp cât i este mai mic de 5.

Do ( i += 1; console.log(i); ) în timp ce (i< 5);

buclă while

Bucla while execută expresii atâta timp cât condiția este adevărată. Arata cam asa:

În timp ce (condiție) expresii

Dacă condiția devine falsă, expresiile din buclă se opresc din executare și controlul trece la expresia după buclă.

Condiția este verificată pentru a fi adevărată înainte ca expresiile din buclă să fie executate. Dacă condiția este adevărată, expresiile sunt executate și apoi condiția este testată din nou. Dacă condiția este falsă, execuția este suspendată și controlul trece la expresia după while .

Pentru a utiliza mai multe expresii, utilizați un bloc de expresii ( ... ) pentru a le grupa.

Exemplul 1

Următoarea buclă while rulează atâta timp cât n este mai mic de trei:

Var n = 0; var x = 0; în timp ce (n< 3) { n++; x += n; }

Cu fiecare iterație, bucla crește n și adaugă acea valoare la x. Prin urmare, x și n obțin următoarele valori:

• După prima trecere: n = 1 și x = 1
• După al doilea: n = 2 și x = 3
• După a treia trecere: n = 3 și x = 6

După a treia trecere, condiția n< 3 становится ложным, поэтому цикл прерывается.

Exemplul 2

Evitați buclele nesfârșite. Asigurați-vă că condiția buclei devine în cele din urmă falsă; în caz contrar, ciclul nu va fi niciodată întrerupt. Expresiile din următoarea buclă while vor rula pentru totdeauna deoarece condiția nu va deveni niciodată falsă:

În timp ce (adevărat) ( ​​console.log ("Bună ziua, lume"); )

Eticheta

O etichetă este o declarație cu un identificator care vă permite să vă referiți la un loc în program. De exemplu, puteți folosi o etichetă pentru a indica o buclă și apoi utilizați instrucțiuni break sau continue pentru a indica dacă programul ar trebui să întrerupă bucla sau să o continue executarea.

Sintaxa etichetei este următoarea:

Etichetă: operator

Sens Etichete poate fi orice identificator JavaScript valid care nu este un cuvânt rezervat. Operator , cea pe care o specificați după etichetă poate fi orice expresie.

Exemplu

În acest exemplu, markLoop reprezintă o buclă while.

MarkLoop: while (theMark == true) (​do Something(); )

pauză

Utilizați instrucțiunea break pentru a întrerupe o buclă, a schimba controlul sau în combinație cu instrucțiunea etichetă.

• Când utilizați break fără etichetă, întrerupe while , do-while și for loops sau comută imediat controlul la următoarea expresie.
• Când utilizați pauză cu un semn, se rupe expresia marcată special.

Sintaxa operatorului ar putea fi:

pauză;

pauză Eticheta;

Prima formă de sintaxă rupe bucla cu totul sau comută controlul; al doilea întrerupe o expresie special desemnată.

Exemplul 1

Următorul exemplu iterează prin elementele dintr-o matrice până când găsește un element a cărui valoare este theValue:

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

Exemplul 2: Etichetă întrerupere var x = 0; var z = 0 labelCancelLoops: while (true) ( ​​​​console.log ("Bucla exterioară: " + x); x += 1; z = 1; while (adevărat) ( ​​console.log ("Bucla interioară: " + z) ; z += 1; if (z === 10 && x === 10) ( break labelCancelLoops; ) else if (z === 10) ( break; ) ) ) continua

Declarația continue este folosită pentru a avansa cu un pas în while , do-while , pentru bucle sau pentru a sări la o etichetă.

• Când utilizați continue fără o etichetă, întrerupe iterația curentă a while , do-while și for bucle și continuă bucla de la următoarea iterație. Spre deosebire de break , continue nu întrerupe complet execuția buclei. În bucla while, trece la condiția. Și pentru asta crește pasul.
• Când utilizați continuare cu o etichetă, aceasta este aplicată buclei cu acea etichetă.

Sintaxa de continuare ar putea arăta astfel:

continua;

continua Eticheta ;

Exemplul 1

Următorul exemplu arată o buclă while cu o instrucțiune continue care se declanșează atunci când valoarea lui i este 3. Astfel, n primește valorile 1, 3, 7 și 12.

Var i = 0; var n = 0; in timp ce eu< 5) { i++; if (i == 3) { continue; } n += i; }

Exemplul 2

Expresia marcată checkiandj conţine expresia marcată verificaj. Când întâlnește continuare, programul anulează iterația curentă verificajși începe următoarea iterație. De fiecare dată când întâlniți, continuați, verificaj continuă la următoarea iterație atâta timp cât condiția returnează false . Când se returnează false după calcularea restului unei diviziuni checkiandj, checkiandj continuă la următoarea iterație atâta timp cât condiția sa revine false. Când este returnat false, programul continuă execuția cu expresia after checkiandj.

Dacă este marcat Continuare checkiandj, programul poate continua de la începutul semnului checkiandj.

Checkiandj: în timp ce (i< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( continua verificarea j; ) console.log(j + „chiar.”); ) console.log(„i = " + i); console.log("j = " + j); )

pentru...în

Instrucțiunea for...in iterează prin toate proprietățile enumerabile ale unui obiect. JavaScript va executa expresiile specificate pentru fiecare proprietate individuală. Bucla for...in arată astfel:

Pentru (variabilă în obiect) (expresii)

Exemplu

Următoarea funcție ia ca argument un obiect și numele acestuia. Apoi iterează prin toate proprietățile obiectului și returnează un șir care conține numele proprietăților și valorile acestora.

Funcția dump_props(obj, obj_name) ( var rezultat = ""; for (var i in obj) (rezultat += obj_name + "." + i + " = " + obj[i] + "
"; ) rezultat += ""; returnează rezultatul; )

Pentru un obiect auto cu proprietăți de marcă și model, rezultat voi :

Car.make = mașină Ford.model = Mustang

Exemplul nr. 2

De asemenea, puteți afișa valoarea prin tastă:

Fiți obj = (model: „AUDI A8”, anul: „2019”, culoare: „maro”) pentru (cheie în obj) ( console.log(`$(key) = $(obj)`); ) // model = AUDI A8 // an = 2019 // culoare = maro

Matrice

Deși este tentant să folosești for...in ca o modalitate de a itera prin toate elementele unui Array, acest operator returnează numele proprietăților definite de utilizator în plus față de indecșii numerici. Astfel, este mai bine să folosiți standard for pentru indecși numerici atunci când interacționați cu matrice, deoarece instrucțiunea for...in iterează peste proprietățile definite de utilizator în plus față de elementele matricei dacă modificați matricea, cum ar fi adăugarea de proprietăți și metode.

Pentru( variabil de obiect) { expresii}

Următorul exemplu arată diferența dintre for...of și for...in bucle. În timp ce pentru...în iterează peste numele proprietăților, for...of iterează peste valorile proprietăților:

Fie arr = ; arr.foo = „bună ziua”; pentru (lasă i în arr) ( console.log(i); // afișează „0”, „1”, „2”, „foo” ) pentru (lasă i din arr) ( console.log(i); / / iese „3”, „5”, „7”)

Buclele sunt expresii speciale care vă permit să executați același bloc de cod de mai multe ori. Execuția codului este întreruptă atunci când apare o anumită condiție.

JavaScript oferă programatorilor mai multe tipuri de bucle. Să le aruncăm o privire mai atentă.

Bucla cu contor

Ciclu cu un contor este convenabil dacă un anumit cod trebuie executat de un număr strict definit de ori. Acesta este probabil cel mai comun tip de ciclu.

O buclă cu un numărător este scrisă astfel:

pentru (; ; )

Cuvântul cheie for este folosit aici. Prin urmare, astfel de bucle sunt adesea numite „bucle pentru”.

Expresia de inițializare este executată foarte întâi și o singură dată. Alocă o variabilă specială numită contor de buclă unei valori inițiale (de obicei 1). Contorul de bucle numără de câte ori a fost executat corpul buclei - codul real care trebuie executat de un anumit număr de ori.

Următorul pas este verificarea stării. Determină momentul în care execuția buclei va fi întreruptă și următorul cod va începe să se execute. De obicei, condiția compară valoarea contorului buclei cu valoarea sa legată. Dacă condiția revine adevărată, corpul buclei este executat, în caz contrar bucla se termină și codul care urmează buclei începe execuția.

După trecerea prin corpul buclei, se execută expresia de increment, modificând valoarea contorului. Această expresie crește de obicei contorul (își mărește valoarea cu unu). Apoi, se verifică din nou condiția, se execută corpul buclei, se execută incrementul etc., până când condiția devine falsă.

Exemplu de buclă cu un numărător:

pentru (i = 1; i< 11; i++) {
a += 3;
b = i * 2 + 1;
}

Această buclă va fi executată de 10 ori. Atribuim contorului i o valoare inițială de 1 și după fiecare execuție a corpului buclei îl creștem cu unul. Bucla se va opri când contorul crește la 11 și condiția buclei devine falsă.

Contorul de bucle poate fi scris într-una dintre expresiile corpului buclei, așa cum am făcut noi. În cazul nostru, contorul i va conține valori crescătoare succesive de la 1 la 10, care sunt utilizate în calcule.

Iată încă două exemple de buclă cu un contor:

pentru (i = 10; i > 0; i--) (
a += 3;
b = i * 2 + 1;
}

Aici valoarea contorului este decrementată. Valoarea sa inițială este 10. Bucla va fi executată de 10 ori și se va termina când contorul i conține 0; în acest caz, valorile acestuia din urmă vor scădea succesiv de la 10 la 1.

pentru (i = 2; i< 21; i += 2) b = i * 2 + 1;

Și în acest exemplu, valoarea inițială a contorului este 2, iar valoarea finală este 21, dar bucla va fi executată, din nou, de 10 ori. Și totul pentru că valoarea contorului crește cu 2 și ia succesiv valorile 2, 4, 6... 20.

Bucla cu postcondiție

O buclă de postcondiție este mult ca o buclă de contor: rulează atâta timp cât condiția buclei rămâne adevărată. Mai mult, condiția este verificată nu înainte, ci după execuția corpului buclei, motiv pentru care bucla cu o postcondiție și-a primit numele. O astfel de buclă va fi executată cel puțin o dată, chiar dacă starea sa este falsă de la bun început.

Format buclă cu postcondiție:

do

in timp ce();

Pentru a defini o buclă cu o postcondiție, sunt furnizate cuvintele cheie do și while, motiv pentru care astfel de bucle sunt adesea numite „bucle do-while”.

Iată un exemplu de buclă cu o postcondiție:

face (
a = a * i + 2;
++i;
) In timp ce< 100);

Iată un alt exemplu:

var a = 0, i = 1;
face (
a = a * i + 2;
++i;
) in timp ce eu< 20);

Deși aici ar fi mai convenabil să folosim o buclă cu un contor care ne este deja familiar și special conceput pentru astfel de cazuri.

Buclă cu precondiție

O buclă cu o precondiție diferă de o buclă cu o postcondiție prin faptul că condiția este verificată înainte de a executa corpul buclei. Deci, dacă (condiția) este inițial falsă, bucla nu va fi executată nici măcar o dată:

in timp ce()

Pentru a crea o buclă cu o postcondiție, este furnizat cuvântul cheie while. Prin urmare, astfel de bucle sunt numite și „bucle în timp ce” (a nu se confunda cu „buclele do-while”!).

Exemplu de buclă cu o precondiție:

In timp ce< 100) {
a = a * i + 2;
++i;
}

Întreruperea și repornirea unui ciclu

Uneori este necesar să se întrerupă execuția unei bucle. Pentru a realiza acest lucru, JavaScript oferă programatorilor Web instrucțiuni break and continue.

Operatorul break vă permite să întrerupeți execuția unei bucle și să treceți la următoarea expresie:

In timp ce< 100) {
a = a * i + 2;
dacă (a > 50) rupere;
++i;
}

În acest exemplu, întrerupem bucla dacă valoarea variabilei a depășește 50.

Operatorul de repornire Continuare vă permite să reporniți bucla, adică să lăsați toate expresiile ulterioare incluse în corpul buclei neexecutate și să începeți să executați bucla de la bun început: verificarea condiției, executarea incrementului și a corpului etc.

Exemplu:

In timp ce< 100) {
i = ++i;
dacă (i > 9 && i< 11) continue;
a = a * i + 2;
}

Aici sărim peste expresia care evaluează a pentru toate valorile lui i de la 10 la 20.