TypScript-Wiederholungsanweisungen

Dieser Artikel erklärt die Wiederholungsanweisungen in TypeScript.

YouTube Video

Die for-Anweisung in TypeScript

Die for-Anweisung in TypeScript ist eine grundlegende Schleifenstruktur zur Durchführung wiederholter Operationen. In einer for-Schleife kann derselbe Codeblock basierend auf einer bestimmten Anzahl von Wiederholungen oder Bedingungen erneut ausgeführt werden.

Grundlegende Syntax

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

• *initialization: Dies ist der Teil, der erst einmal vor Beginn der Schleife ausgeführt wird. Variablen wie Schleifenzähler initialisieren.
• **Bedingungen (bedingung)*: Bestimmt, ob die Schleife weitergeht. Wenn wahr, schleifen Sie weiter, und wenn falsch, beenden.
• **Update (update)*: Am Ende jeder Schleife laufen und den Schleifenzähler aktualisieren.

Beispiel 1: Grundlegende for-Schleife

Im folgenden Beispiel gibt sie die Zahlen von 0 bis 4 der Reihe nach aus.

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

Beispiel 2: for-Schleife mit einem Array

Sie können eine for-Schleife verwenden, um die Elemente eines Arrays der Reihe nach zu verarbeiten.

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

Beispiel 3: for-in-Schleife

Die for-in-Schleife wird verwendet, um die Eigenschaften eines Objekts oder die Indizes eines Arrays der Reihe nach zu durchlaufen.

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

Beispiel 4: for-of-Schleife

Die for-of-Schleife wird verwendet, um die Werte der Elemente in der richtigen Reihenfolge aus iterierbaren Objekten wie Arrays oder Strings abzurufen.

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

Beispiel 5: Geschachtelte for-Schleife

Es ist auch möglich, eine for-Schleife innerhalb einer anderen for-Schleife zu verwenden, was als verschachtelte Schleife bezeichnet wird. Dies ermöglicht unter anderem das Erstellen von Doppelschleifen.

 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

Zusammenfassung

• Die for-Anweisung führt wiederholte Verarbeitung basierend auf angegebenen Zählungen oder Bedingungen aus.
• for-in wird verwendet, um die Eigenschaften eines Objekts oder die Indizes eines Arrays abzurufen.
• for-of ruft die Werte von Elementen aus iterierbaren Objekten wie Arrays ab.
• Komplexe wiederholte Verarbeitung ist auch mit geschachtelten for-Schleifen möglich.

Die for-Anweisung in TypeScript bietet leistungsstarke und flexible Wiederholungsprozesse, ähnlich wie andere Schleifen.

While-Anweisungen in TypeScript

In TypeScript ist eine while-Anweisung eine Schleifenkonstruktion, die einen wiederholenden Prozess ausführt, solange die angegebene Bedingung true ist. Ähnlich wie die for-Schleife eignet sich die while-Schleife für Fälle, in denen die Anzahl der Durchläufe nicht im Voraus festgelegt ist, oder wenn Sie die Wiederholung basierend auf einer Bedingung steuern möchten.

Grundlegende Syntax

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

• Bedingung: Die Bedingung, unter der die Schleife ausgeführt wird. Die Schleife läuft weiter, solange diese Bedingung true ist, und stoppt, sobald sie false wird.

Beispiel 1: Grundlegende while-Schleife

Im folgenden Beispiel wird der Wert von i ausgegeben, solange i kleiner als 5 ist.

 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

In diesem Beispiel endet die Schleife, wenn i 5 oder größer wird, da die Bedingung false wird.

Beispiel 2: Beispiel für eine Endlosschleife

Wenn die Bedingung in einer while-Schleife immer true ist, kann sie zu einer Endlosschleife werden. Dies führt normalerweise dazu, dass das Programm nicht wie beabsichtigt anhält, daher ist Vorsicht geboten.

 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

Sie können die break-Anweisung verwenden, um die Schleife bei Erfüllung einer Bedingung gewaltsam zu verlassen.

Beispiel 3: do-while-Schleife

Die do-while-Schleife ist eine Struktur, bei der der Schleifenprozess mindestens einmal ausgeführt wird. Da die Bedingung nach dem Prozess geprüft wird, läuft der Prozess mindestens einmal, selbst wenn die Bedingung false ist.

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

In diesem Beispiel ist j von Anfang an 5, und j < 5 ist false, aber in einer do-while-Schleife wird sie unabhängig von der Bedingung mindestens einmal ausgeführt.

Zusammenfassung

• Eine while-Schleife wiederholt die Verarbeitung, solange die Bedingung true ist.
• Wenn die Bedingung für den Abbruch der Schleife unklar ist, müssen Sie auf Endlosschleifen achten.
• Eine do-while-Schleife unterscheidet sich von einer normalen while-Schleife dadurch, dass die Verarbeitung mindestens einmal ausgeführt wird.

Die while-Anweisung in TypeScript ist nützlich für Schleifenprozesse mit unklarer Anzahl von Iterationen oder wenn eine dynamische Überprüfung von Bedingungen erforderlich ist.

break und continue

Sie können break und continue innerhalb von Schleifen verwenden.

• break wird verwendet, um eine Schleife vorzeitig zu beenden.
• continue wird verwendet, um die aktuelle Iteration zu überspringen und zur nächsten Iteration zu wechseln.

Beispiel für 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

In diesem Fall wird break ausgeführt, wenn i den Wert 5 erreicht. Als Ergebnis werden die Zahlen von 0 bis 4 angezeigt.

Beispiel für 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

In diesem Fall wird continue ausgeführt, wenn i den Wert 2 erreicht. Als Ergebnis werden alle Zahlen außer 2 angezeigt.

Verschachtelte Schleifen in TypeScript

Eine verschachtelte Schleife ist eine Struktur, bei der eine Schleife in einer anderen Schleife verwendet wird. In TypeScript werden Schleifenkonstrukte wie for, while und do-while unterstützt. Durch die Verwendung von verschachtelten Schleifen können Sie zweidimensionale Arrays (Matrizen) verarbeiten und die Verarbeitung basierend auf mehreren Bedingungen optimieren.

Grundlegende Syntax

Die grundlegende Syntax einer verschachtelten Schleife lautet wie folgt.

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}

Für jede Ausführung der äußeren Schleife durchläuft die innere Schleife alle ihre Iterationen. Diese Struktur ist sehr nützlich, wenn mehrere Schleifen oder Datenstrukturen verarbeitet werden müssen.

Beispiel für eine verschachtelte Schleife in TypeScript

Durchlaufen eines zweidimensionalen Arrays

Verschachtelte Schleifen werden häufig verwendet, wenn mehrdimensionale Datenstrukturen wie zweidimensionale Arrays bearbeitet werden. Im folgenden Beispiel werden Elemente eines zweidimensionalen Arrays durchlaufen und ihre Werte auf der Konsole angezeigt.

 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

In diesem Beispiel durchlaufen wir das zweidimensionale Array matrix. Die äußere Schleife bearbeitet die Zeilen, und die innere Schleife bearbeitet die Spalten, wobei jedes Element der Reihe nach angezeigt wird.

Kombination von zwei Arrays

Als Nächstes stellen wir ein Beispiel für die Berechnung aller Kombinationen von zwei Arrays vor. Zum Beispiel können Sie aus jedem der beiden Arrays ein Element entnehmen und alle möglichen Paare ausgeben.

 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)

In diesem Beispiel werden alle Paare zwischen dem String-Array array1 und dem Zahlen-Array array2 erstellt. Die äußere Schleife extrahiert Elemente aus array1, und die innere Schleife extrahiert Elemente aus array2, wobei jedes Paar angezeigt wird.

Erzeugen von Koordinaten mit einer dreifachen Schleife

Durch die Verwendung von dreifach geschachtelten Schleifen können Sie beispielsweise Koordinaten in einem dreidimensionalen Raum generieren.

 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)

Auf diese Weise können Sie mit dreifach geschachtelten Schleifen problemlos Koordinaten in einem dreidimensionalen Raum erzeugen.

Leistung von geschachtelten Schleifen

Geschachtelte Schleifen sind praktisch, aber die Rechenkosten steigen rapide an, wenn die Schachtelungstiefe zunimmt. Zum Beispiel, wenn die äußere Schleife n Durchläufe und die innere Schleife m Durchläufe hat, ergibt sich die Gesamtanzahl der Durchläufe zu n * m. Wenn dies weiter verschachtelt wird, steigt die Berechnungskomplexität exponentiell an, was die Programmleistung beeinträchtigen könnte.

Nachfolgend sind die Berechnungskomplexitäten beim Durchlaufen von drei Arrays aufgeführt.

 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}

In diesem Fall müssen Sie array1.length * array2.length * array3.length berechnen, was zu 3 * 3 * 3 = 27 Durchläufen führt, um alle Kombinationen zu verarbeiten.

Optimierung von geschachtelten Schleifen

Bei der Verwendung geschachtelter Schleifen können Sie die Leistung durch folgende Optimierungen verbessern.

1. Frühe Rückgaben einführen: Beenden Sie die Schleife frühzeitig, wenn das Ziel erreicht ist, um unnötige Iterationen zu vermeiden.
2. Schleifenvariablen cachen: Cachen Sie die Werte von Variablen, die innerhalb der Schleife verwendet werden (insbesondere Längen und Bereiche), um die Berechnungskosten bei jeder Iteration zu reduzieren.
3. Datenstrukturen ändern: Die Überarbeitung der Struktur von Arrays und Objekten kann wirksam sein, um spezifische, sich wiederholende Prozesse zu beschleunigen.

Fazit

Geschachtelte Schleifen sind ein leistungsstarkes Werkzeug in der komplexen Datenverarbeitung und Algorithmen. Allerdings können mit zunehmender Schachtelungstiefe und Anzahl der Iterationen Leistungsprobleme auftreten. Mit geeigneten Optimierungen und sorgfältiger Gestaltung können Sie geschachtelte Schleifen in TypeScript effektiv nutzen.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video