TypeScript repetisjonssetninger

Denne artikkelen forklarer repetisjonssetninger i TypeScript.

YouTube Video

for-setningen i TypeScript

for-setningen i TypeScript er en grunnleggende løkkestruktur for å utføre gjentatte operasjoner. I en for-løkke kan den samme kodeblokken utføres flere ganger basert på et spesifisert antall eller betingelser.

Grunnleggende Syntax

1for (initialization; condition; update) {
2    // Code to execute repeatedly while the condition is true
3}

• Initialisering (initialisering): Delen som kjøres kun én gang før løkken starter. Initialiser variabler som løkketelleren.
• Betingelse (betingelse): Betingelsen som bestemmer om løkken skal fortsette. Hvis sann, fortsetter løkken; hvis falsk, avsluttes den.
• Oppdatering (oppdatering): Dette kjøres på slutten av hver løkke for å oppdatere løkketelleren.

Eksempel 1: Grunnleggende for-løkke

I eksemplet nedenfor skriver det ut tallene fra 0 til 4 i rekkefølge.

1for (let i = 0; i < 5; i++) {
2    console.log("The value of i is: " + i);
3}
4// Outputs:
5// The value of i is: 0
6// The value of i is: 1
7// The value of i is: 2
8// The value of i is: 3
9// The value of i is: 4

Eksempel 2: for-løkke med en array

Du kan også bruke en for-løkke for å prosessere elementene i en array i rekkefølge.

1let fruits: string[] = ["apple", "banana", "cherry"];
2
3for (let i = 0; i < fruits.length; i++) {
4    console.log("Fruit: " + fruits[i]);
5}
6// Outputs:
7// Fruit: apple
8// Fruit: banana
9// Fruit: cherry

Eksempel 3: for-in-løkke

for-in-løkka brukes til å iterere over egenskapene i et objekt eller indeksene i en array i rekkefølge.

1let car = { brand: "Toyota", model: "Corolla", year: 2020 };
2
3for (let key in car) {
4    console.log(key + ": " + car[key]);
5}
6// Outputs:
7// brand: Toyota
8// model: Corolla
9// year: 2020

Eksempel 4: for-of-løkke

for-of-løkka brukes til å hente verdien til hvert element i rekkefølge fra iterable objekter som arrays eller strenger.

1let colors: string[] = ["red", "green", "blue"];
2
3for (let color of colors) {
4    console.log("Color: " + color);
5}
6// Outputs:
7// Color: red
8// Color: green
9// Color: blue

Eksempel 5: Nestet for-løkke

Det er også mulig å bruke en for-løkke inne i en annen for-løkke, kjent som en nestet løkke. Dette lar deg lage doble løkker, blant annet.

 1for (let i = 0; i < 3; i++) {
 2    console.log("Outer loop i: " + i);
 3    for (let j = 0; j < 2; j++) {
 4        console.log("  Inner loop j: " + j);
 5    }
 6}
 7// Outputs:
 8// Outer loop i: 0
 9//   Inner loop j: 0
10//   Inner loop j: 1
11// Outer loop i: 1
12//   Inner loop j: 0
13//   Inner loop j: 1
14// Outer loop i: 2
15//   Inner loop j: 0
16//   Inner loop j: 1

Sammendrag

• for-setningen utfører repeterende prosessering basert på angitte antall eller betingelser.
• for-in brukes til å hente egenskapene til et objekt eller indeksene til et array.
• for-of henter verdiene til elementene fra iterbare objekter som arrays.
• Kompleks repeterende prosessering er også mulig med nestede for-løkker.

for-setningen i TypeScript tilbyr kraftig og fleksibel repetitiv prosessering, på linje med andre løkker.

While-setninger i TypeScript

I TypeScript er en while-setning en løkkekonstruksjon som utfører en repetitiv prosess mens den angitte betingelsen er true. I likhet med for-løkka er while-løkka egnet for tilfeller der antall iterasjoner ikke er forutbestemt, eller når du ønsker å kontrollere repetisjonen basert på en betingelse.

Grunnleggende Syntax

1while (condition) {
2    // Code to execute repeatedly while the condition is true
3}

• Betingelse: Betingelsen som løkka kjører under. Løkka fortsetter så lenge denne betingelsen er true, og stopper når den blir false.

Eksempel 1: Grunnleggende while-løkke

I eksempelet under fortsetter den å skrive ut verdien av i mens i er mindre enn 5.

 1let i: number = 0;
 2
 3while (i < 5) {
 4    console.log("The value of i is: " + i);
 5    i++;
 6}
 7// Outputs:
 8// The value of i is: 0
 9// The value of i is: 1
10// The value of i is: 2
11// The value of i is: 3
12// The value of i is: 4

I dette eksempelet avsluttes løkka når i blir 5 eller større fordi betingelsen blir false.

Eksempel 2: Eksempel på en uendelig løkke

Hvis betingelsen i en while-løkke alltid er true, kan den bli en uendelig løkke. Dette fører vanligvis til at programmet ikke stopper som ment, så forsiktighet er nødvendig.

 1let x: number = 0;
 2
 3while (true) {
 4    console.log("The value of x is: " + x);
 5    x++;
 6    if (x >= 5) {
 7        break; // Exit the loop when the condition is met
 8    }
 9}
10// Outputs:
11// The value of x is: 0
12// The value of x is: 1
13// The value of x is: 2
14// The value of x is: 3
15// The value of x is: 4

Du kan bruke break-setningen for å avslutte løkka med tvang når en betingelse er oppfylt.

Eksempel 3: do-while-løkke

do-while-løkka er en struktur der løkkeprosessen utføres minst én gang. Siden betingelsen evalueres etter prosessen, kjører prosessen minst én gang, selv om betingelsen er false.

1let j: number = 5;
2
3do {
4    console.log("The value of j is: " + j);
5    j++;
6} while (j < 5);
7// Outputs: The value of j is: 5

I dette eksempelet er j 5 fra starten, og j < 5 er false, men i en do-while-løkke kjører den minst én gang uavhengig av betingelsen.

Sammendrag

• En while-løkke gjentar prosesseringen så lenge betingelsen er true.
• Hvis betingelsen for å avslutte løkka er uklar, må du være forsiktig med uendelige løkker.
• En do-while-løkke skiller seg fra en vanlig while-løkke ved at prosesseringen utføres minst én gang.

while-setningen i TypeScript er nyttig for løkkeprosessering med usikkert antall iterasjoner eller når dynamisk betingelsessjekk er nødvendig.

break og continue

Du kan bruke break og continue i løkker.

• break brukes for å avslutte en løkke tidlig.
• continue brukes for å hoppe over den nåværende iterasjonen og gå til neste iterasjon.

Eksempel på break

 1for (let i = 0; i < 10; i++) {
 2    if (i === 5) {
 3        break;  // Exits the loop when i is 5
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 2, 3, 4
 8
 9let i = 0;
10while (i < 10) {
11    if (i === 5) {
12        break;  // Ends the loop when i is 5
13    }
14    console.log(i);
15    i++;
16}
17// Outputs 0, 1, 2, 3, 4

I dette tilfellet utføres break når i blir 5. Som et resultat vises tallene fra 0 til 4.

Eksempel på continue

 1for (let i = 0; i < 5; i++) {
 2    if (i === 2) {
 3        continue;  // Skips when i is 2
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 3, 4
 8
 9let i = 0;
10while (i < 5) {
11    if (i === 2) {
12        i++;
13        continue;  // Skips when i is 2
14    }
15    console.log(i);
16    i++;
17}
18// Outputs 0, 1, 3, 4

I dette tilfellet utføres continue når i er 2. Som et resultat vises tallene unntatt 2.

Nøstede løkker i TypeScript

En nøstet løkke er en struktur der en løkke brukes inni en annen løkke. I TypeScript støttes løkkekonstruksjoner som for, while og do-while. Ved å bruke nøstede løkker kan du behandle flerdimensjonale matriser og effektivisere prosessering basert på flere betingelser.

Grunnleggende Syntax

Den grunnleggende syntaksen for en nøstet løkke er som følger.

1for (let i: number = 0; i < n; i++) {
2    for (let j: number = 0; j < m; j++) {
3        // Processing for the inner loop
4    }
5}

For hver utføring av den ytre løkken, fullfører den indre løkken alle sine iterasjoner. Denne strukturen er svært nyttig når man arbeider med flere løkker eller datastrukturer.

Eksempel på en nøstet løkke i TypeScript

Gjennomgang av en todimensjonal matrise

Nøstede løkker brukes ofte når man jobber med flerdimensjonale datastrukturer som todimensjonale matriser. I følgende eksempel blir elementene i en todimensjonal matrise gjennomgått, og verdiene deres vises i konsollen.

 1const matrix: number[][] = [
 2    [1, 2, 3],
 3    [4, 5, 6],
 4    [7, 8, 9]
 5];
 6
 7for (let row: number = 0; row < matrix.length; row++) {
 8    for (let col: number = 0; col < matrix[row].length; col++) {
 9        console.log(`matrix[${row}][${col}] = ${matrix[row][col]}`);
10    }
11}
12// Output
13// matrix[0][0] = 1
14// matrix[0][1] = 2
15// matrix[0][2] = 3
16// matrix[1][0] = 4
17// matrix[1][1] = 5
18// matrix[1][2] = 6
19// matrix[2][0] = 7
20// matrix[2][1] = 8
21// matrix[2][2] = 9

I dette eksempelet går vi gjennom den todimensjonale matrisen matrix. Den ytre løkken behandler radene, og den indre løkken behandler kolonnene, og viser hvert element i rekkefølge.

Kombinasjon av to arrayer

Deretter introduserer vi et eksempel på å beregne alle kombinasjoner av to arrayer. For eksempel kan du ta ett element fra hver av to arrayer og skrive ut alle mulige par.

 1const array1: string[] = ['A', 'B', 'C'];
 2const array2: number[] = [1, 2, 3];
 3
 4for (let i: number = 0; i < array1.length; i++) {
 5    for (let j: number = 0; j < array2.length; j++) {
 6        console.log(`Pair: (${array1[i]}, ${array2[j]})`);
 7    }
 8}
 9// Output
10// Pair: (A, 1)
11// Pair: (A, 2)
12// Pair: (A, 3)
13// Pair: (B, 1)
14// Pair: (B, 2)
15// Pair: (B, 3)
16// Pair: (C, 1)
17// Pair: (C, 2)
18// Pair: (C, 3)

I dette eksempelet opprettes alle par mellom strengarrayen array1 og tallarrayen array2. Den ytre løkken henter elementer fra array1, og den indre løkken henter elementer fra array2, og viser hvert par.

Generere koordinater med en trippel løkke

Ved hjelp av trippel-nestede løkker kan du for eksempel generere koordinater i et tredimensjonalt rom.

 1for (let x: number = 0; x < 3; x++) {
 2    for (let y: number = 0; y < 3; y++) {
 3        for (let z: number = 0; z < 3; z++) {
 4            console.log(`Coordinate: (${x}, ${y}, ${z})`);
 5        }
 6    }
 7}
 8// Output
 9// Coordinate: (0, 0, 0)
10// Coordinate: (0, 0, 1)
11// Coordinate: (0, 0, 2)
12// ...
13// Coordinate: (2, 2, 1)
14// Coordinate: (2, 2, 2)

På denne måten kan du enkelt generere koordinater i et tredimensjonalt rom ved å bruke trippel-nestede løkker.

Ytelse til nestede løkker

Nestede løkker er praktiske, men beregningskostnaden øker raskt med løkke-dybden. For eksempel, hvis det er n iterasjoner av den ytre løkken og m iterasjoner av den indre løkken, vil det totale antallet iterasjoner være n * m. Når dette blir ytterligere nestet, øker den beregningsmessige kompleksiteten eksponentielt, noe som kan påvirke programytelsen.

Nedenfor er de beregningsmessige kompleksitetene ved gjennomgang av tre arrayer.

 1const array1: number[] = [1, 2, 3];
 2const array2: number[] = [4, 5, 6];
 3const array3: number[] = [7, 8, 9];
 4
 5for (let i: number = 0; i < array1.length; i++) {
 6    for (let j: number = 0; j < array2.length; j++) {
 7        for (let k: number = 0; k < array3.length; k++) {
 8            console.log(`Combination: (${array1[i]}, ${array2[j]}, ${array3[k]})`);
 9        }
10    }
11}

I dette tilfellet kjører løkken et antall ganger lik produktet av lengdene på array1, array2 og array3, noe som resulterer i totalt 27 iterasjoner for å behandle alle kombinasjoner.

Optimalisering av nestede løkker

Når du bruker nestede løkker, kan du forbedre ytelsen ved å vurdere følgende optimaliseringer.

1. Innfør tidlig avslutning: Avslutt løkken tidlig når målet er oppnådd for å unngå unødvendige iterasjoner.
2. Bufre løkkevariabler: Forhåndsbufre verdiene til variabler som brukes i løkken (spesielt lengder og områder) for å redusere beregningskostnadene hver gang.
3. Endre datastrukturer: Å revidere strukturen til arrayer og objekter kan være effektivt for å fremskynde spesifikke repetitive prosesser.

Konklusjon

Nestede løkker er et kraftig verktøy i kompleks databehandling og algoritmer. Men etter hvert som løkke-dybden og antallet iterasjoner øker, kan ytelsesproblemer oppstå. Med riktige optimaliseringer og nøye design kan du effektivt utnytte nestede løkker i TypeScript.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video