TypeScript Gentagelsesudsagn

Denne artikel forklarer gentagelsesudsagnene i TypeScript.

YouTube Video

for-sætningen i TypeScript

for-sætningen i TypeScript er en grundlæggende løkkestruktur til at udføre gentagne operationer. I en for-løkke kan den samme kodeblok gentagne gange udføres baseret på et angivet antal eller betingelser.

Grundlæggende syntaks

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

• initialisering: Dette er den del, der udføres kun én gang før du starter sløjfen. Indledende variabler såsom loop-tællere.
• Vilkår (herefter): Løser, om sløjfen fortsætter. Hvis det er tilfældet, skal du fortsætte med at loop, og hvis det er falsk, afslutte.
• Opdater (’update’): Kør i slutningen af hver løkke og opdatere loop-tælleren.

Eksempel 1: Grundlæggende for-løkke

I eksemplet nedenfor udskriver det tallene fra 0 til 4 i rækkefø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å bruge en for-løkke til at bearbejde elementerne i en array i rækkefø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økken bruges til at iterere over egenskaberne i et objekt eller indeksene i en array i rækkefø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økken bruges til at hente hver elements værdi i rækkefølge fra itererbare objekter som arrays eller strenge.

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: Indlejret for-løkke

Det er også muligt at bruge en for-løkke inden i en anden for-løkke, kendt som en indlejret løkke. Dette giver dig mulighed for at oprette dobbeltløkker blandt andre ting.

 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-sætningen udfører gentagen behandling baseret på angivne antal eller betingelser.
• for-in bruges til at hente egenskaberne for et objekt eller indekserne for en array.
• for-of henter værdierne af elementer fra itererbare objekter som arrays.
• Kompleks gentagen behandling er også muligt med indlejrede for-løkker.

for-udsagnet i TypeScript tilbyder kraftfuld og fleksibel gentagelsesbehandling, ligesom andre løkker.

While-udsagn i TypeScript

I TypeScript er en while-udsagn en løkkekonstruktion, der udfører en gentagelsesproces, så længe den angivne betingelse er true. Ligesom for-løkker er while-løkker velegnede til situationer, hvor antallet af iterationer ikke er forudbestemt, eller når du vil styre gentagelsen baseret på en betingelse.

Grundlæggende syntaks

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

• Betingelse: Den betingelse, hvorunder løkken udføres. Løkken fortsætter, så længe denne betingelse er true, og stopper, når den bliver false.

Eksempel 1: Grundlæggende while-løkke

I eksemplet nedenfor fortsætter den med at outputte værdien af i, så længe i er mindre end 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 eksempel slutter løkken, når i bliver 5 eller større, fordi betingelsen bliver false.

Eksempel 2: Eksempel på uendelig løkke

Hvis betingelsen i en while-løkke altid er true, kan den blive en uendelig løkke. Dette forårsager normalt, at programmet ikke stopper som tilsigtet, så forsigtighed 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 bruge break-udsagnet til at tvinge løkken til at stoppe, når en betingelse er opfyldt.

Eksempel 3: do-while-løkke

do-while-løkker er en struktur, hvor løkkerne udføres mindst én gang. Da betingelsen evalueres efter processen, køres processen mindst én gang, selvom 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 eksempel er j 5 fra starten, og j < 5 er false, men i en do-while-løkke udføres den mindst én gang uanset betingelsen.

Sammendrag

• En while-løkke gentager processen, så længe betingelsen er true.
• Hvis betingelsen for at afslutte løkken er uklar, skal du være forsigtig med uendelige løkker.
• En do-while-løkke adskiller sig fra en normal while-løkke ved, at processen udføres mindst én gang.

while-udsagnet i TypeScript er nyttigt til løkkebehandling med usikre iterationsantal eller når dynamisk betingelseskontrol er nødvendig.

break og continue

Du kan bruge break og continue inden for løkker.

• break bruges til at afslutte en løkke før tid.
• continue bruges til at springe den nuværende iteration over og gå til den næste iteration.

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;
10
11while (i < 10) {
12    if (i === 5) {
13        break;  // Ends the loop when i is 5
14    }
15    console.log(i++);
16}
17// Outputs 0, 1, 2, 3, 4

I dette tilfælde udføres break, når i bliver 5. Som 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;
10
11while (i < 5) {
12    i++;
13    if (i === 3) {
14        continue;  // Skips when i is 3
15    }
16    console.log(i);
17}
18// Outputs 1, 2, 4, 5

I dette tilfælde udføres continue, når i er 2. Som resultat vises alle tal undtagen 2.

Indlejrede løkker i TypeScript

En indlejret løkke er en struktur, hvor en løkke bruges inden i en anden løkke. I TypeScript understøttes løkkekonstruktioner som for, while og do-while. Ved at bruge indlejrede løkker kan du håndtere to-dimensionelle arrays (matricer) og forenkle behandling baseret på flere betingelser.

Grundlæggende syntaks

Den grundlæggende syntaks for en indlejret 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 udførelse af den ydre løkke afslutter den indre løkke alle sine iterationer. Denne struktur er meget nyttig, når man arbejder med flere løkker eller datastrukturer.

Eksempel på en indlejret løkke i TypeScript

Gennemløb af et to-dimensionelt array

Indlejrede løkker bruges ofte til at håndtere flerdimensionelle datastrukturer som to-dimensionelle arrays. I det følgende eksempel gennemløbes elementerne i et to-dimensionelt array, og deres værdier 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 eksempel gennemløber vi det to-dimensionelle array matrix. Den ydre løkke håndterer rækkerne, og den indre løkke håndterer kolonnerne og viser hvert element i rækkefølge.

Kombination af to arrays

Næste gang præsenterer vi et eksempel på beregning af alle kombinationer af to arrays. For eksempel kan du tage et element fra hvert af de to arrays og udskrive 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 eksempel oprettes alle par mellem strengarrayet array1 og talarrayet array2. Den ydre løkke udtrækker elementer fra array1, og den indre løkke udtrækker elementer fra array2 og viser hvert par.

Generering af koordinater med en tredobbelt løkke

Ved at bruge tredobbelt indlejrede løkker kan du for eksempel generere koordinater i et tredimensionelt rum.

 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åde gør brugen af tredobbelt indlejrede løkker det nemt at generere koordinater i et tredimensionelt rum.

Ydeevne for indlejrede løkker

Indlejrede løkker er praktiske, men den beregningsmæssige omkostning stiger hurtigt, når løkkedybden øges. Hvis der for eksempel er n iterationer af den ydre løkke og m iterationer af den indre løkke, vil det samlede antal iterationer være n * m. Når dette yderligere indlejres, øges den beregningsmæssige kompleksitet eksponentielt, hvilket potentielt påvirker programmets ydeevne.

Nedenfor ses de beregningsmæssige kompleksiteter ved gennemgang af tre arrays.

 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 tilfælde skal du beregne array1.length * array2.length * array3.length, hvilket resulterer i 3 * 3 * 3 = 27 iterationer for at behandle alle kombinationer.

Optimering af indlejrede løkker

Når du bruger indlejrede løkker, kan du forbedre ydeevnen ved at overveje følgende optimeringer.

1. Introducer tidlige afslutninger: Afbryd løkken tidligt, når målet er nået, for at undgå unødvendige iterationer.
2. Gem løkkevariabler i cache: Forhåndsgem værdierne af variabler, der bruges i løkken (især længder og intervaller), for at reducere beregningsomkostningerne hver gang.
3. Ændr datastrukturer: At revidere strukturen af arrays og objekter kan være effektivt til at fremskynde specifikke gentagne processer.

Konklusion

Indlejrede løkker er et kraftfuldt værktøj i kompleks databehandling og algoritmer. Men når løkkedybden og antallet af iterationer stiger, kan der opstå ydeevneproblemer. Med passende optimeringer og omhyggelig design kan du effektivt udnytte indlejrede løkker i TypeScript.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video