Sista gången loopen körs är när i är lika. Slingor och iterationer

|

Eftersom while och do...while är villkorade, exekveras de när det givna påståendet utvärderas till sant. För uttalandet är också baserat på villkor, men det ger ytterligare funktioner, till exempel en loopräknare, som låter dig ställa in antalet loopiterationer i förväg.

Denna handledning kommer att lära dig hur du använder för, för...av och för...in loopar, som är integrerade delar av programmering i JavaScript.

för slingor

En for-loop kan använda upp till tre valfria uttryck för att återutförande kodblock.

Låt oss titta på loopsyntaxen.

för (initiering; villkor; slutligt uttryck) (
// kod som ska köras
}

• Initiering (om specificerad) startar räknaren och deklarerar variablerna.
• Villkoret behandlas härnäst. Om sant, kommer programmet att köra följande kod; om det är falskt kommer slingan att bryta.
• Sedan bearbetas koden som behöver exekveras.
• Om ett slutligt uttryck anges uppdateras det, varefter loopen återgår till att bearbeta villkoret.

För att förstå hur detta fungerar, låt oss titta på ett grundläggande exempel.

för (låt i = 0; i< 4; i++) {
// Skriv ut varje iteration till konsolen
console.log(i);
}

Om du kör den här koden får du detta resultat:

0
1
2
3

I exemplet ovan för slinga börjar med variabeln let i = 0, vilket startar slingan med värdet 0. Villkoret i anges i slingan< 4, а это означает, что до тех пор, пока значение i меньше 4, цикл будет продолжать работу. Финальное выражение i++ определяет счетчик для каждой итерации цикла. console.log(i) выводит числа, начиная с 0, и останавливается, как только i равняется 4.

Utan loopen skulle koden som gör samma sak vara:

// Sätt initial variabel till 0
låt i = 0;
// Öka variabeln manuellt med 1 fyra gånger
console.log(i++);
console.log(i++);
console.log(i++);
console.log(i++);

Utan en loop består ett kodblock av fler rader. För att öka antalet nummer skulle vi behöva lägga till ännu fler rader i koden.

Låt oss titta på varje uttryck i slingan.

Initialisering

Det första uttrycket i slingan är initialisering.

Den deklarerar en variabel i med nyckelordet let (du kan också använda nyckelordet var) och tilldelar den värdet 0. Du kan använda valfritt variabelnamn i dina loopar, men variabeln i är associerad med ordet "iteration" och gör det inte överbelasta koden.

Skick

Gilla while och do...while loops, för loopar har oftast ett tillstånd. I i detta exempel Detta:

Detta betyder att uttrycket evalueras till sant så länge som värdet på i är mindre än 4.

Slutligt uttryck

Detta är ett uttryck som exekveras i slutet av varje slinga. Det används oftast för att öka eller minska värdet på en variabel, men det kan användas för andra ändamål.

I det här exemplet ökar loopen variabeln med en. Uttrycket i++ gör samma sak som i = i + 1.

Till skillnad från start och villkor slutar det slutliga uttrycket inte med semikolon.

Slingkropp

Nu känner du till alla komponenterna i en for-loop. Låt oss titta på koden igen.

// Initiera en for-sats med 5 iterationer
för (låt i = 0; i< 4; i++) {
console.log(i);
}

Det första uttrycket specificerar det initiala värdet för variabeln (0), det andra definierar villkoret (loopen exekveras så länge som i är mindre än 4), och det tredje specificerar steget för varje iteration (i I detta fall värdet ökar med 1).

Konsolen kommer att mata ut värdena: 0, 1, 2 och 3. Slingan bryts då.

Valfria uttryck

Alla för loop-uttryck är valfria. Till exempel kan du skriva samma sak för loop, men hoppa över initieringen och initiera variabeln utanför loopen.

låt i = 0;
// Initiera loopen
för (;i< 4; i++) {
console.log(i);
}
0
1
2
3

I det här fallet indikerar det första semikolontecknet att början saknas.

Notera: Även om du inte använder ett av uttrycken måste du inkludera semikolon, annars kommer loopen att tolkas felaktigt.

Som ett exempel kan du också ta bort villkoret från slingan. För att stoppa loopen när värdet på en variabel blir större än 3, använd if och break.

// Deklarera variabel utanför loopen
låt i = 0;
//Uteslut initiering och villkor
för (; ; i++) (
om (i > 3) (
ha sönder;
}
console.log(i);
}
0
1
2
3

Viktig! I loopar utan villkor måste du använda break-satsen. Annars kommer loopen inte att kunna bryta (sådana loopar kallas oändliga) och kommer att få webbläsaren att krascha.

Du kan också ta bort det slutliga uttrycket från slingan. Steget kan specificeras i slutet av loopkoden. I det här fallet måste du lämna båda tecknen ";" inom parentes, annars fungerar inte loopen.

// Deklarera variabel utanför loopen
låt i = 0;
//Uteslut alla påståenden
för (; ;) (
om (i > 3) (
ha sönder;
}
console.log(i);
i++;
}
0
1
2
3

Som du kan se producerar loop-uttryck den mest koncisa och läsbara koden.

Ändra arrayer

En for-loop kan användas för att modifiera arrayer.

I följande exempel visar hur man skapar tom array och fyll den med variabler med hjälp av en loopräknare. Skapa en modifyArray.js-fil och lägg till följande kod till den:

// Initiera tom array
låt arrayExample = ;
// Initiera loop för att köras 3 gånger
för (låt i = 0; i< 3; i++) {
// Uppdatera array med variabelvärde
arrayExample.push(i);
console.log(arrayExample);
}

Starta programmet. Det kommer att mata ut:

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

Den givna slingan exekveras tills i< 3 перестанет быть истинным. Массив arrayExample выводится в консоль в конце каждой итерации. Так вы можете увидеть, как массив пополняется новыми значениями.

Arraylängd

Ibland måste en loop köras flera gånger, men det är svårt att bestämma det erforderliga antalet iterationer. Istället för att deklarera antalet iterationer, som i de tidigare exemplen, kan du använda egenskapen length för att få slingan att köras lika många gånger som det finns element i arrayen.

// Deklarera array med 3 objekt
låt fiska = [ "flundra", "lax", "gädda" ];
//Initialisera för att loopen ska köras för den totala längden av en array
för (låt i = 0; i< fish.length; i++) {
// Skriv ut varje objekt till konsolen
console.log(fisk[i]);
}

Ett sådant program kommer att ge resultatet:

flundra
lax
gädda

Denna loop itererar genom varje arrayindex med fisk[i]. Detta gör att indexet uppdateras dynamiskt med varje iteration.

Cyklar

För att förstå effekten av villkorliga uttalanden föreslog vi att man skulle föreställa sig dem som vägskäl längs med vilken JavaScript-tolkaren rör sig. Slingor kan ses som en U-sväng på vägen som tar dig tillbaka, vilket tvingar tolken att gå igenom samma kod om och om igen.

I JavaScript Det finns fyra loopar: while, do/while, for och for/in. Ett av följande underavsnitt ägnas åt var och en av dem. En vanlig användning av loopar är att korsa elementen i en array.

medan loop

If-satsen är grundläggande villkorlig operatör i JavaScript-språket, och den grundläggande loopen för JavaScript kan betraktas som while-loopen. Den har följande syntax:

medan (uttryck) (instruktion)

While-slingan börjar med att utvärdera ett uttryck. Om detta uttryck utvärderas till falskt, hoppar tolken över påståendet som utgör slingans kropp och går till följande instruktioner i ett program. Om uttrycket evalueras till sant, exekveras satsen som utgör slingans kropp, sedan överförs kontrollen till början av slingan och uttrycket utvärderas igen. Med andra ord, tolken exekverar slingkroppsinstruktionen om och om igen så länge som värdet på uttrycket förblir sant. Observera att det är möjligt att skapa en oändlig loop med hjälp av while(true) syntaxen.

Vanligtvis vill du inte att JavaScript-tolken ska utföra samma operation om och om igen. I nästan varje loop, med varje iteration av loopen, ändrar en eller flera variabler sina värden. Eftersom variabeln ändras, kan vad instruktionen gör skilja sig åt varje gång den passerar genom slingkroppen.

Dessutom, om variabeln/variablerna som modifieras finns i uttrycket, kan värdet på uttrycket ändras för varje gång i slingan. Detta är viktigt eftersom annars kommer uttrycket vars värde var sant aldrig att förändras och loopen kommer aldrig att ta slut! Nedan är ett exempel på en while-loop som skriver ut siffrorna från 0 till 9:

Var-antal = 0; medan (räkna

Som du kan se är räknevariabeln satt till 0 i början, och sedan ökas dess värde varje gång slingans body exekveras. Efter att loopen har körts 10 gånger kommer uttrycket att returnera false (det vill säga att count-variabeln inte längre är mindre än 10), medan-satsen avslutas och tolken går vidare till nästa sats i programmet. De flesta loopar har räknarvariabler som liknar count. Oftast fungerar variabler som heter i, j och k som loopräknare, men för att göra det programkod mer förståeligt bör räknare ges mer beskrivande namn.

do/while loop

En do/while-loop liknar på många sätt en while-loop, förutom att looputtrycket testas i slutet snarare än i början. Detta innebär att slingans kropp alltid exekveras minst en gång. Denna instruktion har följande syntax:

göra (påstående) medan (uttryck);

Do/while loop används mer sällan än sin syster while loop. Faktum är att i praktiken är situationen när du i förväg är säker på att du kommer att behöva utföra slingans kropp minst en gång något ovanlig. Nedan är ett exempel på hur du använder en do/while loop:

Funktion printArray(a) ( var len = a.length, i = 0; if (len == 0) console.log("Empty array"); else ( do ( console.log(a[i]); ) while (++i

Det finns två skillnader mellan en do/while loop och en vanlig while loop. För det första kräver en do-loop både nyckelordet do (för att markera början av loopen) och nyckelordet while (för att markera slutet av loopen och ange ett villkor). För det andra, till skillnad från en while-loop, slutar en do-loop med semikolon. While-slingan behöver inte sluta med semikolon om slingans kropp är innesluten i tandställning.

för slinga

En for-loop är en loopkonstruktion som ofta är bekvämare än en while-loop. For-slingan gör det enkelt att konstruera slingor som följer ett mönster som är gemensamt för de flesta slingor. De flesta loopar har någon form av räknarvariabel. Denna variabel initieras innan loopen startar och kontrolleras före varje iteration. Slutligen inkrementeras eller modifieras räknarvariabeln i slutet av loopkroppen, precis innan variabeln kontrolleras igen. Initiering, verifiering och uppdatering är de tre nyckeloperationerna som utförs med loop variabel. For-satsen gör dessa tre steg explicit till en del av loopsyntaxen:

for(initiering; kontroll; inkrement) (instruktion)

Initiera, kontrollera och inkrementera är tre uttryck (separerade med semikolon) som är ansvariga för att initiera, kontrollera och öka en loopvariabel. Genom att placera dem på den första raden i slingan blir det lättare att förstå vad for-slingan gör och förhindrar att du glömmer att initiera eller öka en loopvariabel.

Det enklaste sättet att förklara for-slingan är att visa motsvarande while-loop:

initiering; while(check) (instruktion; inkrement;)

Med andra ord, initialiseringsuttrycket utvärderas en gång innan loopen börjar. Detta uttryck är vanligtvis ett uttryck med biverkningar (vanligtvis en uppgift). JavaScript tillåter också att initialiseringsuttrycket är en var-variabeldeklarationssats, så det är möjligt att deklarera och initiera en loopräknare samtidigt.

Testuttrycket utvärderas före varje iteration och avgör om slingans kropp kommer att exekveras. Om resultatet av testet är sant, exekveras instruktionen som är slingans kropp. I slutet av slingan utvärderas inkrementuttrycket. För att detta uttryck ska vara meningsfullt måste det vara ett uttryck med biverkningar. Vanligtvis är detta antingen ett tilldelningsuttryck eller ett uttryck som använder operatorn ++ eller --.

Du kan också skriva ut siffrorna 0 till 9 med en for-loop, som visas nedan, i motsats till motsvarande while-loop som visades i exemplet tidigare:

För (var count = 0; count

Naturligtvis kan cyklerna vara mycket mer komplexa än dessa enkla exempel, och ibland ändras flera variabler i varje iteration av loopen. Denna situation är den enda gången i JavaScript där kommaoperatorn ofta används - den låter dig kombinera flera initialiserings- och inkrementeringsuttryck till ett enda uttryck som är lämpligt för användning i en for-loop:

Var i,j; för (i = 0, j = 0; i

för/i slinga

For/in-slingan använder nyckelordet for, men det är helt annorlunda än en vanlig for-loop. For/in-loopen har följande syntax:

för (variabel i objekt) (påstående)

Variabeln här är vanligtvis namnet på variabeln, men du kan också använda var-satsen, som deklarerar en enskild variabel. Objektparametern är ett uttryck som returnerar ett objekt. Och som vanligt är en instruktion en instruktion eller block av instruktioner som utgör kroppen av en loop.

För att korsa elementen i en array är det naturligt att använda en vanlig for-loop:

Var arr = ; för (var i = 0; i

For/in-satsen låter dig naturligtvis också gå igenom egenskaperna hos ett objekt:

// Skapa ett nytt objekt var obj = (namn:"Alex", lösenord:"12345" ); for (var i i obj) ( // Skriv ut värdet för varje objektegenskap console.log(obj[i]); )

För att köra en for/in-sats utvärderar JavaScript-tolken först expressionsobjektet. Om det kommer tillbaka nullvärde eller odefinierad, hoppar tolken över slingan och går vidare till nästa instruktion. Om uttrycket returnerar ett enkelt värde, konverteras det till ett ekvivalent omslagsobjekt. Annars returnerar uttrycket ett objekt. Tolken exekverar sedan en iteration av loopen för varje uppräknad egenskap hos objektet. Före varje iteration utvärderar tolken uttryckets värde, lagrar det i en variabel och tilldelar det ett egenskapsnamn (ett strängvärde).

Slingor är designade för att utföra samma instruktioner om och om igen.

Det finns 4 typer av loopar i JavaScript:

• For-slingan. Denna slinga används när det exakta antalet repetitioner av samma instruktioner är känt.
• Medan loop. Den är utformad för att utföra samma instruktioner så länge som ett givet villkor är sant.
• Gör ... medan loopen. Denna cykel liknar en while-loop, men villkoret kontrolleras inte före exekvering av upprepade satser, utan efter dem. På detta sätt, till skillnad från en while-loop, kommer satserna att köras minst en gång, även om villkoret initialt är falskt.
• Den för...in loop. Den används när du behöver iterera genom alla egenskaper i ett objekt eller varje element i en array.

för slinga

För loopsyntax:

För (initiering; villkor; slutligt uttryck) ( /* loop body */ )

• initialisering är ett uttryck som exekveras en gång innan slingan exekveras; används vanligtvis för att initiera en räknare;
• ett villkor är ett uttryck vars sanning kontrolleras före varje iteration; om uttrycket utvärderas till sant, utförs iteration, annars avslutas for-loopen;
• det slutliga uttrycket är uttrycket som exekveras i slutet av varje iteration; används vanligtvis för att byta räknare;
• loop body - instruktioner som behöver upprepas.

Låt oss titta på ett exempel på en slinga som kommer att skriva ut nummer från 1 till 9 till konsolen:

Var i; // För slinga från 1 till 9, i steg om 1 för (i = 1; i 4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( fortsätt checkj; ) console.log(j + " jämnt." ) console.log("i = " + i); console.log("j = " + j); )

för...in

For...in-satsen itererar genom alla uppräknade egenskaper hos ett objekt. JavaScript kommer att exekvera de angivna uttrycken för varje enskild egenskap. For...in loopen ser ut så här:

För (variabel i objekt) (uttryck)

Exempel

Följande funktion tar ett objekt och dess namn som argument. Den itererar sedan igenom alla egenskaper för objektet och returnerar en sträng som innehåller egenskapsnamnen och deras värden.

Funktion dump_props(obj, obj_name) ( var result = ""; for (var i i obj) ( resultat += obj_name + "." + i + " = " + obj[i] + "
"; ) resultat += ""; returnera resultat; )

För ett bilobjekt med märkes- och modellegenskaper, resultat kommer :

Bil.märke = Ford bil.modell = Mustang

Exempel nr 2

Du kan också visa värdet med nyckel:

Låt obj = (modell: "AUDI A8", år: "2019", färg: "brun") för (skriv in obj) ( console.log(`$(key) = $(obj)`); ) // modell = AUDI A8 // år = 2019 // färg = brun

Matriser

Även om det är frestande att använda för... på ett sätt att iterera genom alla element i en Array, returnerar denna operator namnet på användardefinierade egenskaper utöver de numeriska indexen. Därför är det bättre att använda standard för för numeriska index när du interagerar med arrayer, eftersom for...in-satsen itererar över användardefinierade egenskaper utöver arrayelementen om du modifierar arrayen, som att lägga till egenskaper och metoder.

För( variabel av objekt) { uttryck}

Följande exempel visar skillnaden mellan for...of och for...in loops. Medan för...in itererar över egenskapsnamn, för...of itererar över egenskapsvärden:

Låt arr = ; arr.foo = "hej"; for (låt i arr) ( console.log(i); // skriver ut "0", "1", "2", "foo" ) för (låt i av arr) ( console.log(i); / / anger "3", "5", "7")

JavaScript-loopar låter dig utföra repetitiva beräkningar om och om igen. De optimerar kodningsprocessen genom att exekvera samma sats eller block av satser som utgör kroppen av en loop ett visst antal gånger (med en räknarvariabel) eller medan ett specificerat villkor är sant. Slingor itererar över en sekvens av värden. Att köra en loop en gång kallas iteration.

En loops prestanda påverkas av antalet iterationer och antalet operationer som utförs i loopkroppen för varje iteration.

I JavaScript finns det följande operatörer cykel:

1) för används när du i förväg vet hur många gånger du behöver göra något;
2) for...in används för att korsa objektens egenskaper;
3) while används när du inte vet hur många gånger du behöver göra något;
4) do...while fungerar på samma sätt som while-satsen. Det skiljer sig i att göra ... samtidigt som uttrycket alltid utförs i lockiga hängslen, men minst en gång, även om tillståndstestet returnerar false .

Typer av loopar i JavaScript, loopkontroll 1. För slinga

For-loopen används för att iterera genom elementen i arrayer eller arrayliknande objekt som argument och HTMLCollection. Villkoret kontrolleras före varje iteration av slingan. Om kontrollen lyckas exekveras koden inuti slingan, annars exekveras inte koden inuti slingan och programmet fortsätter från första raden omedelbart efter slingan.

Nästa loop kommer att skriva ut raden Hej, JavaScript! Fem gånger.

För (var i = 0; i< 5; i++) { console.log(i + ": Hello, JavaScript!"); }
Ris. 1. Resultat av att köra en for-loop på konsolen

1.1. Hur for-slingan fungerar

For-slingan består av tre olika operationer:

Steg 1. initiering var i = 0; — deklaration av en räknarvariabel som kommer att kontrolleras under loopkörning. Denna variabel initieras med värdet 0. Oftast fungerar variabler som heter i, j och k som loopräknare.

Steg 2. kontroll av skick i< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В данном примере проверка условия идёт до тех пор, пока значение счётчика меньше 5 .

Steg 3. Den sista i++-operationen är räknarökningsoperationen, som ökar värdet på variabeln var i med en. Istället för inkrementoperationen kan även dekrementeringsoperationen användas.

I slutet av slingan lagras variabeln var i vid 1. Nästa iteration av loopen exekveras för (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .

1.2. Skriver ut matrisvärden

För att skriva ut matrisvärden med en for-loop måste du använda egenskapen arraylängd. Detta hjälper dig att bestämma antalet element i arrayen och slinga samma antal gånger.

Skriptet nedan kommer att visa fem meddelanden med namnen på färgerna:

Var blommor = ["Ros", "Lilja", "Tulpan", "Jasmin", "Orkidé"]; för (var i = 0; i< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }

Om värdet längdegenskaperändras inte när loopen körs, du kan lagra den i en lokal variabel och sedan använda den variabeln i ett villkorligt uttryck. På så sätt kan du öka slingans hastighet, eftersom värdet på egenskapen length endast kommer att hämtas en gång under hela slingans varaktighet.

Var flowers = ["Rose", "Lily", "Tulip", "Jasmine", "Orchid"], len = flowers.length; för (var i = 0; i

2. Slinga för...in

For...in loopar används för att korsa egenskaperna hos objekt som inte är matriser. Denna typ av traversering kallas också uppräkning. Vid traversering rekommenderas att använda metoden hasOwnProperty() för att filtrera bort egenskaper som ärvts från prototypen.

Låt oss till exempel skapa ett objekt med hjälp av en bokstavlig objekt.

Var användare = (namn: "Alice", ålder: 25, land: "Ryssland" ); for (var prop i användare) ( console.log(prop + ": " + användare); )
Ris. 2. Resultat av att köra for...in loop på konsolen

Låt oss anta att i ett scenario före eller efter att ha skapat ett användarobjekt, prototypen Objekt utökades ytterligare metod clone() .

If (typeof Object.prototype.clone === "odefinierad") ( Object.prototype.clone = funktion () (); )

Eftersom prototyparvskedjan ständigt kontrolleras av tolken får alla objekt automatiskt tillgång till den nya metoden.

Ris. 3. Resultat av att upprepa for...in loopen på konsolen

För att undvika upptäckt av denna metod medan egenskaperna för användarobjektet räknas upp, används metoden hasOwnProperty() som kommer att filtrera bort egenskaperna för prototypen.

Var användare = (namn: "Alice", ålder: 25, land: "Ryssland" ); if (typeof Object.prototype.clone === "odefinierad") ( Object.prototype.clone = funktion () (); ) för (var prop i användare) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + användare);
Ris. 4. Resultatet av att lista egenskaperna för ett objekt med metoden hasOwnProperty()

3. While loop

While-slingan är en loop med en preliminär kontroll av ett villkorligt uttryck. Satsen inuti slingan (kodblock i klammerparenteser) kommer att köras om det villkorliga uttrycket evalueras till true . Om den första kontrollen returnerar false, kommer blocket med instruktioner inte att utföras ens en gång.

Efter att loopiterationen är klar testas det villkorliga uttrycket igen för sanning och processen upprepas tills uttrycket utvärderas till false . I det här fallet fortsätter programmet från första raden omedelbart efter slingan (om det finns en).

Denna loop visar multiplikationstabellen för talet 3:

Vari = 1; var msg = ""; medan jag< 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg);
Ris. 5. Resultat av att köra while-loopen

4. Gör ... medan loop

Slinga gör...medan; kontrollerar fortsättningsvillkoret efter att slingan exekveras. Till skillnad från while-loopen, i do...while; Slingans kropp exekveras minst en gång, eftersom villkoret kontrolleras i slutet av slingan och inte i början. Denna loop används mer sällan än medan , eftersom det i praktiken är sällsynt att en situation där minst en loopkörning krävs.

Var resultat = ""; var i = 0; gör ( i += 1; resultat += i + " "; ) medan (i< 5); document.write(result);
Ris. 6. Resultat av exekvering av do...while loop

I följande exempel exekveras satserna i en loop en gång, även om villkoret inte är sant.

Vari = 10; do ( document.write(i + " "); i++; ) while (i< 10);

5. Oändliga slingor

När du skapar en loop kan du skapa en oändlig loop som aldrig tar slut. En sådan slinga skulle potentiellt kunna fortsätta att köras så länge som användarens dator är igång. Majoritet moderna webbläsare kan upptäcka detta och uppmana användaren att sluta köra skriptet. För att undvika att skapa en oändlig loop måste du vara säker på att det givna villkoret kommer att returnera falskt någon gång. Till exempel anger följande loop ett villkor som aldrig returnerar falskt eftersom i aldrig kommer att vara mindre än 10:

For (var i = 25; i > 10; i++) ( document.write("Denna mening kommer att köra för alltid...
"); }

6. Kapslade öglor

En slinga inuti en annan slinga kallas en kapslad loop. Med varje iteration av loopen exekveras den kapslade loopen helt. Kapslade loopar kan skapas med en for loop och en while loop.

För (var count = 1; count< 3; count++) { document.write(count + ". Строка цикла
"); för (var nestcount = 1; nestcount< 3; nestcount++) { document.write("Строка вложенного цикла
"); } }
Ris. 7. Resultat av att köra en kapslad för-loop

7. Cykelhantering

Slingan kan styras med break-satser; och fortsätt; .

7.1. Operatörsavbrott;

Operatörsavbrott; avslutar exekveringen av den aktuella slingan. Den används i undantagsfall när slingan av någon anledning inte kan köras, till exempel om applikationen stöter på ett fel. Oftast rastoperatören; är en del av if-konstruktionen.

När uttalandet går sönder; används utan en etikett, låter den dig lämna en loop eller switch-sats. Följande exempel skapar en räknare vars värden bör variera från 1 till 99, men break-satsen bryter loopen efter 14 iterationer.

För (var i = 1; i< 100; i++) { if (i == 15) { break; } document.write(i); document.write("
"); }
Ris. 8. Resultatet av pausoperatorn i for-slingan

För kapslade loopar, break-satsen; används med en etikett som avslutar den namngivna instruktionen. En etikett låter dig lämna vilket kodblock som helst. En namngiven sats kan vara vilken sats som helst utanför en break-sats; . Etiketten kan vara namnet på en if-sats eller namnet på ett block med satser inneslutna i klammerparenteser bara för att tilldela en etikett till det blocket. Mellan nyckelord ha sönder; och etikettnamnet tillåter inte en ny rad.

Outerloop: for(var i = 0; i< 10; i++) { innerloop: for(var j = 0; j < 10; j++) { if (j >3) bryta; // Gå ur den innersta slingan om (i == 2) bryter innerslingan; // Samma sak om (i == 4) break outerloop; // Lämna den yttre slingan document.write("i = " + i + " j = " + j + "
"); ) ) document.write("FINAL i = " + i + " j = " + j + "
");

7.2. Operatören fortsätter;

Operatören fortsätter; stoppar den aktuella loopiterationen och startar en ny iteration. I det här fallet återgår while-slingan direkt till sitt tillstånd, och for-loopen utvärderar först inkrementuttrycket och återgår sedan till villkoret.

Detta exempel visar alla jämna tal:

Var i; för(i = 1; i