TypeScript-Iteratoren und -Generatoren

Iteratoren und Generatoren sind wichtige Muster in JavaScript/TypeScript für die Arbeit mit Sammlungen.

Sie bieten eine einheitliche Möglichkeit, über Daten zu iterieren, was den Umgang mit großen Datenströmen, unendlichen Sequenzen und mehr erleichtert.


SVG-Diagramm: Iteratoren und Generatoren Background Title Iterator and Generator Workflow Iterator Protocol Iterator Protocol Implement Symbol.iterator Return next() method { done, value } Arrow for...of loop for...of loop Automatically calls next() Iterates over all elements Stops when done=true Arrow Generator Generator function* yield pauses Lazy evaluation Bottom section: Generator characteristics Generator Characteristics Feature 1 Lazy evaluation - generates on demand Feature 2 State preservation - pause position Feature 3 Composable - yield* delegation Arrow marker

Warum brauchen wir Iteratoren und Generatoren

Bei der Arbeit mit Sammlungsdaten müssen wir oft über Datenstrukturen wie Arrays und Objekte iterieren.

Iteratoren bieten eine einheitliche, anpassbare Iterationsschnittstelle, die das Iterieren über jedes Objekt ermöglicht.

Generatoren sind eine prägnante Möglichkeit, Iteratoren zu erstellen. Sie ermöglichen das Pausieren und Fortsetzen der Ausführung mithilfe von Funktionen, was sie ideal für die Verarbeitung großer Datenströme oder unendlicher Sequenzen macht.

Konzepterklärung:Ein Iterator ist ein Objekt, das eine next()-Methode zum Durchlaufen von Daten bereitstellt. Ein Generator ist eine spezielle Funktion, die während der Ausführung pausieren und einen Wert zurückgeben kann.


Iterierbares Protokoll

Objekte, die die Methode Symbol.iterator implementieren, können mit einer for...of-Schleife iteriert werden.

Beispiel

// Arrays sind standardmäßig iterierbar
var arr = [1, 2, 3];
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
    var item = arr_1[_i];
    console.log("Array-Elemente: " + item);
}

// Strings sind standardmäßig iterierbar
var str = "hello";
for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
    var char = str_1[_i];
    console.log("Zeichen: " + char);
}

Ausgabe:

数组元素: 1
数组元素: 2
数组元素: 3
字符: h
字符: e
字符: l
字符: l
字符: o

Erklärung:Arrays und Strings besitzen beide integrierte Symbol.iterator-Implementierungen, daher können sie direkt mit for...of iteriert werden.


Benutzerdefinierte iterierbare Objekte

Lassen Sie gewöhnliche Objekte die Symbol.iterator-Schnittstelle implementieren, damit sie iteriert werden können.

Beispiel

// Ein benutzerdefiniertes iterierbares Objekt erstellen: range
var range = {
    from: 1,
    auf: 5,
    // Die Symbol.iterator-Methode implementieren
    [Symbol.iterator]: function() {
        return {
            current: this.from,
            last: this.to,
            // Die nächste Methode gibt das Iterationsergebnis zurück
            next: function() {
                if (this.current <= this.last) {
                    // Noch nicht fertig, den aktuellen Wert zurückgeben und erhöhen
                    return { done: false, value: this.current++ };
                }
                // Fertig
                return { done: true, value: undefined };
            }
        };
    }
};

// Mit for...of iterieren
for (var _i = 0, range_1 = range; _i < range_1.length; _i++) {
    var num = range_1[_i];
    console.log("Bereich: " + num);
}

Iterator-Protokoll:Ein Iterator muss eine next()-Methode haben, die ein Objekt im Format { done: boolean, value: any } zurückgibt.


Generator-Funktionen

Verwende die function*-Syntax, um Generatoren zu erstellen, und verwende yield, um die Ausführung anzuhalten und einen Wert zurückzugeben.

Beispiel

// Generator-Funktion: verwendet function*-Syntax
function* numberGenerator() {
    yield 1;  // Anhalten und 1 zurückgeben
    yield 2;  // Anhalten und 2 zurückgeben
    yield 3;  // Anhalten und 3 zurückgeben
}

// Eine Generator-Instanz erstellen
var gen = numberGenerator();

// Jeder Aufruf von next() wird bis zum nächsten yield ausgeführt
console.log("First: " + gen.next().value);
console.log("Zweite: " + gen.next().value);
console.log("Dritte: " + gen.next().value);
console.log("Fertig: " + gen.next().done);

Ausgabe:

第一个: 1
第二个: 2
第三个: 3
完成: true

Generator:Eine Generatorfunktion gibt einen Iterator zurück, und jeder Aufruf von next() wird bis zur nächsten yield-Anweisung ausgeführt.


Unendliche Generatoren

Generatoren können unendliche Sequenzen erzeugen. Da sie Bedarfsauswertung verwenden, verbrauchen sie keinen unendlichen Speicher.

Beispiel

// Unendlicher Zahlengenerator
// Jeder Aufruf erzeugt nur eine Zahl, nicht alle Zahlen auf einmal
function* infiniteNumbers() {
    var n = 1;
    while (true) {  // Endlosschleife
        yield n++;   // Pausieren und den aktuellen Wert zurückgeben, dann inkrementieren
    }
}

var gen = infiniteNumbers();
console.log("1.: " + gen.next().value);
console.log("2.: " + gen.next().value);
console.log("3.: " + gen.next().value);

// Nur die ersten 5 Zahlen holen
var nums = [];
var iter = infiniteNumbers();
for (var i = 0; i < 5; i++) {
    nums.push(iter.next().value);
}
console.log("Erste 5: " + nums);

Ausgabe:

第1个: 1
第2个: 2
第3个: 3
前5个: 1,2,3,4,5

Lazy Evaluation:Der größte Vorteil von Generatoren ist die Lazy Evaluation: Der nächste Wert wird nur berechnet, wenn next() aufgerufen wird, was sie ideal für den Umgang mit unendlichen Sequenzen macht.


Delegierte Generatoren

Verwende yield*, um an einen anderen Generator oder ein iterierbares Objekt zu delegieren.

Beispiel

// Erster Generator
function* gen1() {
    yield 1;
    yield 2;
}

// Zweiter Generator
function* gen2() {
    yield 3;
    yield 4;
}

// Kombinierter Generator: verwendet yield*-Delegation
function* combined() {
    yield* gen1();  // An gen1 delegieren
    yield* gen2();  // An gen2 delegieren
}

// Über den kombinierten Generator iterieren
for (var _i = 0, combined_1 = combined(); _i < combined_1.length; _i++) {
    var num = combined_1[_i];
    console.log("Wert: " + num);
}

Ausgabe:

值: 1
值: 2
值: 3
值: 4

yield*:Delegierte Generatoren können mehrere Generatoren oder iterierbare Objekte kombinieren, wodurch sie sich gut für den Aufbau wiederverwendbarer Datenströme eignen.


TypeScript-Generator-Typen

Generator-Typannotationen verwenden den Generator-Typ.

Beispiel

// Generator-Typ: Generator<yield-Typ, Rückgabetyp, Typ des next()-Parameters>
function* idGenerator(): Generator<number, void, unknown> {
    var i = 1;
    while (i <= 3) {
        yield i++;  // Typ von yield: number
    }
    // Rückgabe: void
}

var gen = idGenerator();
console.log(Array.from(gen));

Typ-Erklärung:Generator<T, R, N> bedeutet: T ist der Typ von yield, R ist der endgültige Rückgabetyp, und N ist der Typ des next()-Parameters.


Hinweise

  • Iterator-Protokoll:Implementiere Symbol.iterator, um ein Objekt mit einer next()-Methode zurückzugeben.
  • Generator-Syntax:Verwende function* statt function
  • yield-Schlüsselwort:Pausiert die Ausführung und gibt einen Wert zurück.
  • Lazy Evaluation:Generatoren berechnen bei Bedarf und erzeugen nicht alle Werte auf einmal
Best Practices:Verwenden Sie Generatoren bei der Verarbeitung großer Datenströme, unendlicher Sequenzen oder von Szenarien, die Pausieren/Fortsetzen erfordern.

Zusammenfassung

Iteratoren und Generatoren sind leistungsstarke Datenverarbeitungswerkzeuge in TypeScript.

  • Iterierbare Objekte:Implementieren Sie die Schnittstelle Symbol.iterator
  • Generatoren:Erstellt mit function* und yield
  • yield:Ausführung anhalten und Werte zurückgeben
  • Delegation:Verwenden Sie yield*, um mehrere Generatoren zu kombinieren

Empfehlung:Verwenden Sie Iteratoren und Generatoren, wenn Sie benutzerdefinierte Objekte durchlaufen, Datenströme verarbeiten oder unendliche Sequenzen erstellen müssen.

Andere Erweiterungen