De cyclus is controle instructie, waarmee u de uitvoering van programmacode een bepaald aantal keren kunt herhalen. Elke individuele uitvoering van instructies in de hoofdtekst van een lus wordt een iteratie genoemd.

terwijl lus

While-lussyntaxis:

De uitdrukking tussen haakjes wordt de lusuitvoeringsvoorwaarde genoemd, of kortweg voorwaarde. Eerst wordt de waarde van de uitdrukking berekend. De resulterende waarde wordt indien nodig impliciet geconverteerd naar een Booleaans type. Als het resultaat van het evalueren van de expressie waar is, wordt de instructie in de hoofdtekst van de lus uitgevoerd, waarna de besturing wordt overgedragen naar het begin van de lus en de voorwaarde opnieuw wordt geëvalueerd. Als het resultaat van het evalueren van een uitdrukking is waarde vals, beëindigt de tolk de lus en gaat verder met het uitvoeren van de instructie die volgt op de lus. De tolk voert dus de code in de hoofdtekst van de lus keer op keer uit, zolang de voorwaarde waar blijft:

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

do-while-lus

Syntaxis van de do-while-lus:

Een do-while-lus is vergelijkbaar met een while-lus, behalve dat de lusvoorwaarde wordt gecontroleerd na de eerste iteratie in plaats van ervoor, en de lus eindigt met een puntkomma. Omdat de voorwaarde na de iteratie wordt gecontroleerd, wordt de code in de body van de do-while-lus altijd minstens één keer uitgevoerd:

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

Deze lus kan handig zijn als de code in de lusbody minstens één keer moet worden uitgevoerd, ongeacht de uitvoeringsvoorwaarde.

voor lus

Voor lussyntaxis:

Een for-lus bevat drie expressies, gescheiden door puntkomma's. Deze drie expressies hebben de volgende uitvoeringsvolgorde:

De eerste expressie wordt altijd slechts één keer geëvalueerd: vóór de eerste iteratie. Daarom is de eerste expressie meestal de definitie van een variabele die in de lusuitvoeringsvoorwaarde als teller wordt gebruikt.

De tweede expressie definieert de voorwaarde voor het uitvoeren van de lus. Het wordt vóór elke iteratie berekend en bepaalt of het lichaam van de lus wordt uitgevoerd. Als het resultaat van het evalueren van een uitdrukking waar is, programmacode wordt uitgevoerd in de body van de lus. Als false wordt geretourneerd, eindigt de lus en gaat de besturing naar de volgende instructie na de lus. Als de voorwaarde de eerste keer wordt gecontroleerd en deze onwaar blijkt te zijn, wordt de code in de hoofdtekst van de lus niet eens één keer uitgevoerd.

Na elke iteratie wordt de derde uitdrukking geëvalueerd. Meestal wordt het gebruikt om de waarde van een variabele te wijzigen die wordt gebruikt om de toestand van een lus te testen.

Voorbeeld voor lus:

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

Zoals uit het voorbeeld blijkt, voor lus In tegenstelling tot andere lussen kunt u hiermee de code die aan de lus is gekoppeld, op één plek groeperen.

Elk van de expressies in de for-lus mag ontbreken, maar de puntkomma's zelf moeten aanwezig zijn, anders zal dat wel zo zijn syntaxisfout. Als de tweede expressie ontbreekt, loopt de lus voor altijd door.

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

In plaats van één expressie kunt u meerdere expressies opgeven, waarbij u ze scheidt met de komma-operator.

// wordt niet uitgevoerd omdat de laatste expressie in de conditiecontrole onwaar is voor (i = 1; i< 4, false; i++) ... for (var i = 1, j = 5; i , waarmee u meerdere items kunt selecteren). De for-lus declareert een variabele i en stelt de waarde ervan in op 0. Hij controleert ook of i kleiner is dan het aantal elementen in element , voert de if-instructie uit en verhoogt i met één na elke passage door de lus.

Selecteer enkele muziekgenres en klik vervolgens op de onderstaande knop: R&B Jazz Blues New Age Klassieke Opera

functie 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)) });

doe... while-lus

De do...while-lus herhaalt zich zolang de gegeven voorwaarde waar is. De do...while-instructie ziet er als volgt uit:

Doe expressies while(condition);

expressies worden uitgevoerd zolang de voorwaarde waar is. Als u meerdere expressies wilt gebruiken, gebruikt u een blokexpressie ( ... ) om ze te groeperen. Als de voorwaarde waar is, worden de expressies opnieuw uitgevoerd. Aan het einde van elke doorgang wordt de toestand gecontroleerd. Als de voorwaarde onwaar is, wordt de uitvoering opgeschort en wordt de controle overgedragen naar de expressie na do...while .

Voorbeeld

In het volgende voorbeeld wordt de do-lus minimaal één keer uitgevoerd en opnieuw uitgevoerd zolang i kleiner is dan 5.

Doen ( i += 1; console.log(i); ) terwijl (i< 5);

terwijl lus

De while-lus voert expressies uit zolang de voorwaarde waar is. Het ziet er zo uit:

While (voorwaarde)-expressies

Als de voorwaarde onwaar wordt, stoppen de expressies in de lus met uitvoeren en gaat de controle over naar de expressie na de lus.

Er wordt gecontroleerd of de voorwaarde waar is voordat de expressies in de lus worden uitgevoerd. Als de voorwaarde waar is, worden de expressies uitgevoerd en vervolgens wordt de voorwaarde opnieuw getest. Als de voorwaarde onwaar is, wordt de uitvoering opgeschort en wordt de besturing na enige tijd verplaatst naar de uitdrukking.

Als u meerdere expressies wilt gebruiken, gebruikt u een expressieblok ( ... ) om ze te groeperen.

Voorbeeld 1

De volgende while-lus loopt zolang n kleiner is dan drie:

Varn = 0; varx = 0; terwijl (n< 3) { n++; x += n; }

Bij elke iteratie verhoogt de lus n en telt die waarde op bij x. Daarom krijgen x en n de volgende waarden:

• Na de eerste passage: n = 1 en x = 1
• Na de tweede: n = 2 en x = 3
• Na de derde passage: n = 3 en x = 6

Na de derde passage, voorwaarde n< 3 становится ложным, поэтому цикл прерывается.

Voorbeeld 2

Voorkomen eindeloze lussen. Zorg ervoor dat de lusvoorwaarde uiteindelijk onwaar wordt; anders wordt de cyclus nooit onderbroken. De expressies in de volgende while-lus zullen voor altijd worden uitgevoerd omdat de voorwaarde zal nooit onwaar worden:

Terwijl (waar) ( console.log("Hallo wereld"); )

Label

Een label is een verklaring met een identificatie waarmee u naar een bepaalde plaats in uw programma kunt verwijzen. U kunt bijvoorbeeld een label gebruiken om een ​​lus aan te geven en vervolgens break- of continue-instructies gebruiken om aan te geven of het programma de lus moet verbreken of moet doorgaan met het uitvoeren ervan.

De syntaxis van het label is als volgt:

Label: exploitant

Betekenis labels kan elke geldige JavaScript-ID zijn die dat niet is gereserveerd woord. Exploitant , degene die u opgeeft na het label kan elke expressie zijn.

Voorbeeld

In dit voorbeeld vertegenwoordigt de markLoop een while-lus.

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

pauze

Gebruik de break-instructie om een ​​lus te verbreken, de controle te wijzigen of in combinatie met de label-instructie.

• Als je break zonder label gebruikt, breekt het terwijl lussen, do-while en for of schakelt onmiddellijk over naar de volgende expressie.
• Wanneer u break met een markering gebruikt, wordt de speciaal gemarkeerde uitdrukking verbroken.

De syntaxis van de operator zou kunnen zijn:

pauze;

pauze Label;

De eerste vorm van syntaxis doorbreekt de lus helemaal of verandert van besturing; de tweede onderbreekt een speciaal aangewezen uitdrukking.

Voorbeeld 1

In het volgende voorbeeld worden de elementen in een array doorlopen totdat een element wordt gevonden waarvan de waarde theValue is:

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

Voorbeeld 2: Labelonderbreking var x = 0; var z = 0 labelCancelLoops: while (true) ( ​​console.log("Buitenste lus: " + x); x += 1; z = 1; while (true) ( ​​console.log("Binnenste lus: " + z) ; z += 1; if (z === 10 && x === 10) ( break labelCancelLoops; ) else if (z === 10) ( break; ) ) doorgaan

De continue instructie wordt gebruikt om één stap vooruit te gaan in while , do-while , for loops of om naar een label te springen.

• Wanneer u continue zonder label gebruikt, wordt de huidige iteratie van de while , do-while en for loops verbroken en wordt de lus voortgezet vanaf de volgende iteratie. In tegenstelling tot break onderbreekt continue de uitvoering van de lus niet volledig. In de while-lus springt het naar de voorwaarde. En ervoor zorgt dat de stap groter wordt.
• Wanneer u Doorgaan met een label gebruikt, wordt dit toegepast op de lus met dat label.

De continue syntaxis kan er als volgt uitzien:

doorgaan;

doorgaan Label ;

Voorbeeld 1

Het volgende voorbeeld toont een while-lus met een continue-instructie die wordt geactiveerd wanneer de waarde van i 3 is. N krijgt dus de waarden 1, 3, 7 en 12.

Vari = 0; var n = 0; terwijl (ik< 5) { i++; if (i == 3) { continue; } n += i; }

Voorbeeld 2

Uitdrukking gemarkeerd checkiandj bevat de gemarkeerde uitdrukking checkj. Wanneer u continue tegenkomt, breekt het programma de huidige iteratie af checkj en start de volgende iteratie. Elke keer dat je tegenkomt, ga verder, checkj gaat door naar de volgende iteratie zolang de voorwaarde false retourneert. Wanneer false wordt geretourneerd na het berekenen van de rest van een deling checkiandj, checkiandj gaat door naar de volgende iteratie zolang de voorwaarde false retourneert. Wanneer false wordt geretourneerd, gaat het programma verder met de uitvoering vanaf de expressie erna checkiandj.

Als doorgaan is gemarkeerd checkiandj, kan het programma vanaf het begin van de markering doorgaan checkiandj.

Checkiandj: terwijl (i< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( ga door met checkj; ) console.log(j + "even."); ) console.log("i = " + ik);

console.log("j = " + j);

) voor...in De instructie for...in doorloopt alle opsombare eigenschappen van een object. JavaScript voert voor elk de opgegeven expressies uit

aparte eigendom

. De for...in-lus ziet er als volgt uit:

Voor (variabele in object) (expressies)

Voorbeeld
De volgende functie neemt een object en zijn naam als argument. Vervolgens doorloopt het alle eigenschappen van het object en retourneert een tekenreeks die de namen van de eigenschappen en hun waarden bevat.

Functie dump_props(obj, obj_naam) ( var resultaat = ""; for (var i in obj) ( resultaat += obj_naam + "." + i + " = " + obj[i] + " "; ) resultaat += ""; retourneert resultaat; ) Voor een autoobject met merk- en modeleigenschappen geldt:

resultaat

zullen :

Auto.merk = Ford auto.model = Mustang

Voorbeeld nr. 2

U kunt de waarde ook per sleutel weergeven:

Hoewel het verleidelijk is om for... te gebruiken als een manier om alle elementen van een array te doorlopen, retourneert deze operator naast de numerieke indices ook de naam van door de gebruiker gedefinieerde eigenschappen. Het is dus beter om de standaard for te gebruiken voor numerieke indices bij interactie met arrays, aangezien de instructie for...in doorgaat specifieke gebruiker eigenschappen naast de array-elementen als u de array wijzigt, bijvoorbeeld door eigenschappen en methoden toe te voegen.

Voor( variabel van voorwerp) { uitdrukkingen}

Het volgende voorbeeld laat het verschil zien tussen de for...of- en for...in-lussen. Terwijl for...in itereert over eigenschapsnamen, for...of itereert over eigenschapswaarden:

Laat arr = ; arr.foo = "hallo"; for (laat i in arr) ( console.log(i); // print "0", "1", "2", "foo" ) for (laat i van arr) ( console.log(i); / / uitgangen "3", "5", "7")

Laatste update: 04/08/2018

Met loops kun je een actie vele malen uitvoeren, afhankelijk van bepaalde omstandigheden. JavaScript heeft de volgende typen cycli:

voor..in

voor..van

terwijl

doe..terwijl

voor lus

De for-lus heeft de volgende formele definitie:

For ([initialiseer teller]; [voorwaarde]; [verander teller])( // acties )

We gebruiken bijvoorbeeld een for-lus om de elementen van een array te doorlopen:

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

IN in dit geval de array wordt vanaf het einde uitgevoerd en de array wordt herhaald van i = 3 naar i = 0.

voor..in

De for..in-lus is ontworpen om door arrays en objecten te lopen. De formele definitie ervan is:

Voor (index in array) ( // acties )

Laten we bijvoorbeeld de array-elementen herhalen:

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

Lus voor...van

De for...of-lus is vergelijkbaar met de for...in-lus en is ontworpen om verzamelingen te doorlopen, zoals arrays:

Laat gebruikers = ["Tom", "Bob", "Sam"]; for(let val van gebruikers) console.log(val);

Het huidige verzamelingselement dat wordt herhaald, wordt in de val-variabele geplaatst, waarvan de waarde vervolgens naar de console wordt afgedrukt.

terwijl lus

De while-lus loopt zolang een bepaalde voorwaarde waar is. De formele definitie ervan is:

Terwijl(voorwaarde)( // acties )

Nogmaals, we zullen de array-elementen weergeven met while:

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

De while-lus hier wordt uitgevoerd totdat de waarde van index wordt gelijk aan lengte reeks.

doe..terwijl

In een do-lus wordt eerst de luscode uitgevoerd en vervolgens wordt de voorwaarde in de while-instructie gecontroleerd. En zolang deze voorwaarde waar is, herhaalt de cyclus zich. Bijvoorbeeld:

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

Hier wordt de luscode 9 keer uitgevoerd totdat x 10 wordt. De do-lus garandeert dat de acties minstens één keer worden uitgevoerd, zelfs als de voorwaarde in de while-instructie niet waar is.

Ga door met en breek verklaringen

Soms is het nodig om een ​​lus te verlaten voordat deze is voltooid. In dit geval kunnen we de break-instructie gebruiken:

< array.length; i++) { if (array[i] >10) pauze;
"); }

document.write(array[i] + "

Deze lus doorloopt alle elementen van de array, maar de laatste vier elementen worden niet weergegeven in de browser, omdat de test if (array[i] > 10) de lus zal onderbreken met een break-instructie wanneer het itereren door de array bereikt onderdeel 12.

Als we alleen de iteratie willen overslaan, maar de lus niet willen verlaten, kunnen we de instructie continue gebruiken:< array.length; i++) { if (array[i] >Var-array = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; voor (var i = 0; i
"); }

10) doorgaan;

document.write(array[i] + "

Als het programma in dit geval een getal groter dan 10 in de array tegenkomt, wordt dit getal niet in de browser weergegeven.

Heel vaak moet een bepaald deel van een programma vele malen worden uitgevoerd. Dat kunt u uiteraard eenvoudig doen: kopieer en plak het gewenste aantal keren. Dit is echter absurd, vooral als de actie bijvoorbeeld 1000 keer moet worden uitgevoerd. Daarom zijn er zogenaamde loops, die in de meeste programmeertalen aanwezig zijn. En ik zal je over hen vertellen.

Bevat een specifieke code die meerdere keren wordt gescrolld. Er zijn verschillende soorten loops: for, while en do-while.
Laten we beginnen met de allereerste lus (en de meest populaire) - de for-lus. Het algemene uiterlijk van deze cyclus is als volgt:
}

For (iteratie_variabele = initiële_waarde; voorwaarde; actie_na_elke_iteratie) ( //programmacode Laat mij commentaar geven op wat hier geschreven staat. Eerst komt - iteratie variabele. Dit is de normale naam van de variabele voor iteratie. Het volgende komt

initiële_waarde

Voor (i = 0; ik< 100; i++)
. Eigenlijk spreekt de naam voor zich. Vervolgens komt er een voorwaarde: als er aan is voldaan (dat wil zeggen: waar wordt geretourneerd), wordt de lus nog een keer gelanceerd en ten slotte een actie die na elke iteratie wordt uitgevoerd. Meestal is dit een wijziging van een variabele voor de iteratie.

Laten we een eenvoudig script schrijven dat het aantal lusiteraties weergeeft: document.write(i + " ");< 100 Hier hebben we een variabele voor iteratie gedefinieerd (genaamd i) waaraan de waarde 0 is toegewezen. Vervolgens wordt de voorwaarde gecontroleerd: i(dat wil zeggen, het verhogen van de variabele i met 1). De voorwaarde wordt opnieuw gecontroleerd en als deze waar is, wordt er nog een iteratie uitgevoerd. En zo verder tot aan de voorwaarde document.write(i + " ");< 100 zal niet vals worden. Het is duidelijk dat dit pas na 100 iteraties onwaar zal zijn. Deze lus wordt dus 100 keer uitgevoerd, wat we kunnen zien als we dit script uitvoeren. En nog een ding. Omdat we hier maar één operator hebben uitgevoerd (document.write() ), dan de aanwezigheid krullende beugels optioneel. Als er twee of meer operators in een lus draaien, moet u deze installeren.

Laten we het nu hebben over het tweede type lussen in JavaScript - while. In principe lijkt een lus sterk op een for-lus (hoewel alle lussen vergelijkbaar zijn). Maar hier algemeen beeld een andere:

Terwijl (voorwaarde) (
Laten we beginnen met de allereerste lus (en de meest populaire) - de for-lus. Het algemene uiterlijk van deze cyclus is als volgt:
}

Zoals u kunt zien, is er geen variabele voor iteratie, noch enige actie na iteratie. Hieruit volgt de conclusie: om de lus te verlaten, is het noodzakelijk om dit in de lus zelf te doen, zodat " voorwaarde" is false geworden. Als u dit niet doet, ontstaat er een lus en blijft uw script hangen.

Laten we dezelfde taak als voorheen implementeren, maar met behulp van een while-lus.

Vari = 0;
terwijl (ik< 100) {
ik++;
document.write(i + " ");
}

Voordat we de lus startten, hebben we een variabele i gemaakt, waaraan een initiële waarde is toegewezen. Voordat de lus wordt gestart, wordt vervolgens de voorwaarde gecontroleerd, en als deze waar is, wordt een iteratie van de lus gestart, waarbij we de variabele voor iteratie verhogen (anders zal er een lus optreden). En we geven deze variabele weer.

En tot slot is het laatste type loops in JavaScript do-while-lus. De syntaxis is:

Doen(
Laten we beginnen met de allereerste lus (en de meest populaire) - de for-lus. Het algemene uiterlijk van deze cyclus is als volgt:
) terwijl (voorwaarde)

Zeer vergelijkbaar met de while-lus, maar er is maar één ding, en dat is heel erg fundamenteel verschil. Of de while-lus eerst de voorwaarde controleert en vervolgens itereert of niet. De do-while-lus herhaalt zich eerst en controleert dan pas de voorwaarde. En als het onwaar is, verlaat het de lus. Met andere woorden: ongeacht de voorwaarde wordt deze lus gegarandeerd minstens één keer uitgevoerd. Ik denk dat deze code Het zal overbodig zijn, maar toch.

Vari = 0;
Doen (
ik++;
document.write(i + " ");
) terwijl (ik< 100)

Ik zal de code niet uitleggen, ik weet zeker dat je er zonder mij wel achter zult komen. Ik kan dus beter doorgaan met twee interessante uitspraken: breken en doorgaan.

Laten we beginnen met pauze. Deze exploitant zorgt ervoor dat u vroegtijdig uit de cyclus kunt springen. Laten we de volgende code schrijven:

Voor (i = 0; ik< 100; i++) {
als (i == 50) breken;
document.write(i + " ");
}

U kunt dit script uitvoeren en ontdekken dat alleen getallen tot en met 49 worden afgedrukt, want wanneer ik = 50 De lus werd onderbroken dankzij de break-instructie.

Nu heb ik het over de continue-operator. Met deze operator kunt u naar de volgende iteratie van de lus gaan. Om hier niet te veel te beschrijven, is het beter om meteen een voorbeeld te laten zien:

Voor (i = 0; ik< 100; i++) {
als (i == 50) doorgaan;
document.write(i + " ");
}

Als je dit script uitvoert, zul je zien dat het getal 50 ontbreekt. Dit gebeurde omdat wanneer ik = 50, gaan we verder met de volgende iteratie van de lus, waarvoor i met 1 toeneemt en gelijk wordt aan de 51e.

Dat is, zo lijkt het, het enige waar ik over wilde schrijven JavaScript-lussen. Ik hoop dat alles je duidelijk is geworden. Je kunt ook zelf een probleem bedenken en oplossen. Dit wordt een geweldige training.

|

Omdat while en do...while voorwaardelijk zijn, worden ze uitgevoerd wanneer de gegeven instructie true oplevert. De for-instructie is ook gebaseerd op voorwaarden, maar biedt extra functies, zoals een lusteller, waarmee u vooraf het aantal lusiteraties kunt instellen.

In deze tutorial leer je hoe je for, for...of en for...in loops gebruikt, die integrale elementen zijn van programmeren in JavaScript.

voor lussen

Een for-lus kan maximaal drie optionele expressies gebruiken om een ​​codeblok herhaaldelijk uit te voeren.

Laten we eens kijken naar de syntaxis van de lus.

for (initialisatie; voorwaarde; uiteindelijke expressie) (
// code die moet worden uitgevoerd
}

• Initialisatie (indien opgegeven) start de teller en declareert de variabelen.
• De voorwaarde wordt vervolgens verwerkt. Indien waar, zal het programma de volgende code uitvoeren; als het niet waar is, zal de lus breken.
• Vervolgens wordt de code verwerkt die moet worden uitgevoerd.
• Als er een definitieve expressie is opgegeven, wordt deze bijgewerkt, waarna de lus terugkeert naar het verwerken van de voorwaarde.

Laten we een eenvoudig voorbeeld bekijken om te begrijpen hoe dit werkt.

voor (laat i = 0; i< 4; i++) {
// Print elke iteratie naar de console
console.log(i);
}

Als u deze code uitvoert, krijgt u dit resultaat:

0
1
2
3

In het bovenstaande voorbeeld begint de for-lus met de variabele let i = 0, waardoor de lus begint met de waarde 0. De voorwaarde in de lus is i< 4, а это означает, что до тех пор, пока значение i меньше 4, цикл будет продолжать работу. Финальное выражение i++ определяет счетчик для каждой итерации цикла. console.log(i) выводит числа, начиная с 0, и останавливается, как только i равняется 4.

Zonder de lus zou de code die hetzelfde doet er als volgt uitzien:

// Stel de initiële variabele in op 0
laat ik = 0;
// Verhoog de variabele handmatig vier keer met 1
console.log(i++);
console.log(i++);
console.log(i++);
console.log(i++);

Zonder lus bestaat het codeblok uit meer lijnen. Om het aantal cijfers te vergroten, zouden we nog meer regels aan de code moeten toevoegen.

Laten we elke expressie in de lus bekijken.

Initialisatie

De eerste expressie in de lus is initialisatie.

Het declareert de variabele i met behulp van het sleutelwoord let (je kunt ook trefwoord var) en kent er de waarde 0 aan toe. Je kunt elke variabelenaam in lussen gebruiken, maar de i-variabele is geassocieerd met het woord “iteratie” en overbelast de code niet.

Voorwaarde

Zoals while en do...while-lussen, hebben for-lussen meestal een voorwaarde. IN in dit voorbeeld Dit:

Dit betekent dat de uitdrukking resulteert in waar zolang de waarde van i kleiner is dan 4.

Laatste uitdrukking

Dit is een expressie die aan het einde van elke lus wordt uitgevoerd. Het wordt meestal gebruikt om de waarde van een variabele te verhogen of te verlagen, maar het kan ook voor andere doeleinden worden gebruikt.

In dit voorbeeld verhoogt de lus de variabele met één. De uitdrukking i++ doet hetzelfde als i = i + 1.

In tegenstelling tot het begin en de voorwaarde eindigt de laatste expressie niet met een puntkomma.

Luslichaam

Nu ken je alle componenten van een for-lus. Laten we de code nog eens bekijken.

// Initialiseer een for-instructie met 5 iteraties
voor (laat i = 0; i< 4; i++) {
console.log(i);
}

De eerste uitdrukking specificeert oorspronkelijke waarde variabele (0), de tweede definieert de voorwaarde (de lus wordt uitgevoerd terwijl i kleiner is dan 4), en de derde specificeert de stap van elke iteratie (in dit geval zal de waarde met 1 toenemen).

De console geeft de volgende waarden weer: 0, 1, 2 en 3. De lus wordt dan verbroken.

Optionele expressies

Alle for-lus-expressies zijn optioneel. U kunt bijvoorbeeld hetzelfde schrijven voor de lus, maar de initialisatie overslaan en de variabele buiten de lus initialiseren.

laat ik = 0;
// Initialiseer de lus
voor(;ik< 4; i++) {
console.log(i);
}
0
1
2
3

In dit geval geeft de eerste puntkomma aan dat het begin ontbreekt.

Opmerking: zelfs als u een van de uitdrukkingen niet gebruikt, moet u een puntkomma toevoegen, anders wordt de lus verkeerd geïnterpreteerd.

U kunt bijvoorbeeld ook de voorwaarde uit de lus verwijderen. Om de lus te stoppen wanneer de waarde van een variabele groter is dan 3, gebruik je if en break.

// Declareer variabele buiten de lus
laat ik = 0;
// Laat initialisatie en voorwaarde weg
voor (; ; ik++) (
als (ik > 3) (
pauze;
}
console.log(i);
}
0
1
2
3

Belangrijk! In lussen zonder voorwaarde moet je gebruiken verklaring breken. Anders kan de lus niet worden onderbroken (dergelijke lussen worden eindeloos genoemd) en zal de browser crashen.

U kunt ook de laatste expressie uit de lus verwijderen. De stap kan aan het einde van de luscode worden opgegeven. In dit geval moet u beide tekens “;” tussen haakjes laten staan, anders werkt de lus niet.

// Declareer variabele buiten de lus
laat ik = 0;
// Laat alle uitspraken weg
voor (; ;) (
als (ik > 3) (
pauze;
}
console.log(i);
ik++;
}
0
1
2
3

Zoals u kunt zien, produceren lusexpressies de meest beknopte en leesbare code.

Arrays wijzigen

Een for-lus kan worden gebruikt om arrays te wijzigen.

In het volgende voorbeeld ziet u hoe u een lege array maakt en deze met variabelen vult met behulp van een lusteller. Maak een modificArray.js-bestand en voeg de volgende code eraan toe:

// Initialiseer een lege array
laat arrayExample = ;
// Initialiseer de lus zodat deze 3 keer wordt uitgevoerd
voor (laat i = 0; i< 3; i++) {
// Update array met variabele waarde
arrayVoorbeeld.push(i);
console.log(arrayVoorbeeld);
}

Start het programma. Het zal het volgende opleveren:

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

De gegeven lus wordt uitgevoerd totdat i< 3 перестанет быть истинным. Массив arrayExample выводится в консоль в конце каждой итерации. Так вы можете увидеть, как массив пополняется новыми значениями.

Array lengte

Soms moet een lus meerdere keren worden uitgevoerd, maar is het bepalen van het benodigde aantal iteraties lastig. In plaats van het aantal iteraties te declareren, zoals in de voorgaande voorbeelden, kunt u de eigenschap length gebruiken om de lus zo vaak te laten lopen als er elementen in de array staan.

// Declareer array met 3 items
laat vis = [ "bot", "zalm", "snoek" ];
//Initaliseer de lus zodat deze over de totale lengte van een array wordt uitgevoerd
voor (laat i = 0; i< fish.length; i++) {
// Druk elk item af naar de console
console.log(vis[i]);
}

Zo'n programma levert het resultaat op:

bot
zalm
snoek

Deze lus doorloopt elke array-index met behulp van fish[i]. Dit leidt tot dynamische update index bij elke iteratie.