Share
Stel dat je de taak hebt gekregen om een programma te schrijven met de nummers 1-100. Een manier om dit te bereiken is door 100 console.log-instructies te schrijven. Maar ik weet zeker dat je dat niet zou doen, omdat je het zat zou zijn geworden van de 9e of 10e regel.
Het enige deel dat in elke instructie verandert, is het getal, dus er zou een manier moeten zijn om slechts één verklaring te schrijven. En dat is er met loops. Met loops kunnen we een aantal stappen in een codeblok herhaaldelijk uitvoeren.
Hoewel loops herhaaldelijk een reeks instructies uitvoeren terwijl een voorwaarde klopt. Wanneer de voorwaarde onwaar is, zal het programma de lus verlaten. Dit soort lus test de conditie voordat een iteratie wordt uitgevoerd. Een iteratie is een uitvoering van het lichaam van de lus. In het volgende voorbeeld wordt niets weergegeven omdat onze voorwaarde onwaar is.
Accentsconagua
laat hongerig = vals; while (hungry) console.log ("eat"); Dit is de algemene vorm van een while-lus:
while (voorwaarde) statement; uitspraak; enz.
Een ding om op te letten bij het gebruik van while-lussen is het maken van loops die nooit eindigen. Dit gebeurt omdat de voorwaarde nooit onwaar wordt. Als het je overkomt, zal je programma crashen. Voorbeeld:
laat hongerig = waar; while (hungry) console.log ("eat"); Hoe vaak wordt de body van deze lus uitgevoerd:
laat ik = 0; terwijl ik < 10) console.log("Hello, World"); i += 1; Een do-while-lus voert eerst de hoofdtekst van de instructies uit en controleer vervolgens de voorwaarde. Dit soort lus is handig als u weet dat u de code minstens één keer wilt uitvoeren. In het volgende voorbeeld wordt één keer "eten" weergegeven, ook al is de voorwaarde onwaar.
laat hongerig = vals; doe console.log ("eet"); terwijl (hongerig);Dit is de algemene vorm voor een do while-lus:
doen statement; uitspraak; etc. while (voorwaarde);
Schrijf een do-while-lus die de nummers 1-10 weergeeft.
Een for-loop herhaalt de uitvoering van een codeblok voor een bepaald aantal keren. In het volgende voorbeeld worden de nummers 1-10 weergegeven:
voor (let i = 1; i <= 10; i++) console.log(i);
Dit is de algemene vorm van een for-lus:
voor (initiële; voorwaarde; stap) statement; uitspraak; enz.
Eerste is een expressie die de waarde van onze variabele instelt. Staat is een uitdrukking die waar moet zijn voor de uit te voeren uitingen. En stap is een uitdrukking die de waarde van onze variabele verhoogt.
Eén programmeerpatroon is om een for-lus te gebruiken om de waarde van een variabele met zichzelf en een nieuwe waarde bij te werken. Dit voorbeeld somt de nummers 1-10 op:
laat x = 0; voor (let i = 1; i <= 10; i++) x += i; console.log(x) //55
De += is een toewijzingsoperator die een waarde toevoegt aan een variabele. Dit is een lijst met alle toewijzingsoperators:
| operator | Voorbeeld | Gelijkwaardig |
|---|---|---|
| += | x + = 2 | x = x + 2 |
| -= | x - = 2 | x = x - 2 |
| * = | x * = 2 | x = x * 2 |
| / = | x / = 2 | x = x / 2 |
| % = | x% = 2 | x = x% 2 |
Schrijf een for-lus die de faculteit van een getal berekent. De factor van een getal n is het product van alle gehele getallen van 1 tot n. Bijvoorbeeld 4! (4 faculteit) is 1 x 2 x 3 x 4, wat gelijk is aan 24.
Een array is een object met een lijst met items, elementen genaamd, die door hun index worden benaderd. De index is de positie van het element in de array. Het eerste element bevindt zich op de 0-index. Hieronder volgen enkele algemene array-bewerkingen.
Maak een lege array:
laat arr = [];
Initialiseer een array met waarden:
laat arr = [1, 2, "Hallo", "Wereld"];
Kies een element uit een array:
laat arr = [1, 2, "Hallo", "Wereld"]; arr [0] // 1 arr [2] // "Hallo"
Werk een element in een array bij:
laat arr = [1, 2, "Hallo", "Wereld"]; arr [2] = 3; // [1, 2, 3, "Wereld"]
Loop over een array:
laat arr = [1, 2, "Hallo", "Wereld"]; for (let i = 0; i < arr.length; i++) console.log(arr[i]);
Een tweedimensionale array is een array waarvan de elementen arrays zijn. Voorbeeld:
laat arr = [[1, 2], ["Hallo", "Wereld"]]; console.log (arr [0] [1]); // 2
Zo loop je over de array en geef je elk element weer:
for (let i = 0; i < arr.length; i++) for (let j = 0; j < arr[i].length; j++) console.log(arr[ i ][ j ]);
Welk element wordt weergegeven als i = 1 en j = 0 in de bovenstaande lus?
Dit soort lus laat ons door de toetsen in een object lopen. Een object is een gegevensstructuur met sleutels die zijn toegewezen aan waarden. Hier zijn enkele algemene bewerkingen die op een object kunnen worden uitgevoerd.
Maak een leeg object:
laat obj = ;
Initialiseer een object met waarden:
let obj = foo: "Hello", bar: "World";
Koop een woning van een object:
let obj = foo: "Hello", bar: "World"; obj.foo; // "Hallo" obj ["foo"]; //"Hallo"
Een eigenschap in een object bijwerken:
let obj = foo: "Hello", bar: "World"; obj.foo = "hi" obj ["foo"] = "hallo"
Loop over de toetsen van een object:
for (let key in obj) console.log (key);
Wat krijgt bovenstaande als lusweergave obj = foo: "Hello", bar: "World"?
Met dit soort lus kunnen we de waarden van iterabele objecten doorlopen. Voorbeelden van iterabele objecten zijn arrays en strings.
Loop over een array:
laat arr = ["foo", "bar", "baz"]; for (let elem of arr) console.log (elem); // foo bar baz
Loop over een string:
laat str = "Hallo"; for (let char of str) console.log (char); //'Hallo'
Gebruik een van de loops en schrijf een programma dat dit trappenpatroon weergeeft:
# # # # #
Door loops kunnen we de duplicatie in onze code verminderen. Laten we tijdens loops een actie herhalen totdat een voorwaarde onwaar is. Een do-while-lus wordt ten minste één keer uitgevoerd. Laten we voor loops een actie herhalen totdat we het einde van een telling hebben bereikt. De for-in-lus is zo ontworpen dat we toegang hebben tot de sleutels in een object. De for-of-loop is zo ontworpen dat we de waarde van een iterabel object kunnen krijgen.
Vervolgens leren we in deel 4 over functies.
