Penjelasan terperinci tentang iterator dan penjana dalam kemahiran JavaScript_javascript

Memproses setiap item dalam koleksi ialah operasi yang sangat biasa JavaScript menyediakan banyak cara untuk mengulang koleksi, daripada mudah untuk dan untuk setiap gelung kepada peta(), penapis() dan kefahaman tatasusunan . Dalam JavaScript 1.7, iterator dan penjana membawa mekanisme lelaran baharu kepada sintaks JavaScript teras, dan juga menyediakan mekanisme untuk menyesuaikan gelagat untuk...dalam dan untuk setiap gelung.

Iterator

Lelaran ialah objek yang mengakses satu elemen dalam urutan koleksi pada satu masa dan menjejaki kedudukan semasa lelaran dalam jujukan. Dalam JavaScript, iterator ialah objek yang menyediakan kaedah next() yang mengembalikan elemen seterusnya dalam jujukan. Kaedah ini membuang pengecualian StopIteration apabila semua elemen dalam urutan telah dilalui.

Setelah objek iterator dicipta, ia boleh dipanggil secara eksplisit dengan memanggil next() berulang kali, atau secara tersirat menggunakan JavaScript untuk...dalam dan untuk setiap gelung.

Iterators mudah untuk lelaran ke atas objek dan tatasusunan boleh dibuat menggunakan Iterator():

Salin kod Kod adalah seperti berikut:

var lang = { nama: 'JavaScript', tahun lahir: 1995 };
var it = Iterator(lang);

Setelah pemulaan selesai, kaedah next() boleh dipanggil untuk mengakses pasangan nilai kunci objek dalam urutan:

Salin kod Kod adalah seperti berikut:

var pair = it.next(); //Pasangan kunci-nilai ialah ["name", "JavaScript"]
pair = it.next(); //Pasangan kunci-nilai ialah ["hari lahir", 1995]
pair = it.next(); //Pengecualian `StopIteration` dilemparkan

Gelung untuk…dalam boleh digunakan dan bukannya memanggil kaedah seterusnya() secara eksplisit. Gelung ditamatkan secara automatik apabila pengecualian StopIteration dilemparkan.

Salin kod Kod adalah seperti berikut:

var it = Iterator(lang);
untuk (pasangan var di dalamnya)
Print(pair); //Keluarkan satu [kunci, nilai] pasangan nilai kunci di dalamnya setiap kali

Jika anda hanya mahu mengulang nilai kunci objek, anda boleh menghantar parameter kedua ke fungsi Iterator() dengan nilai benar:

Salin kod Kod adalah seperti berikut:

var it = Iterator(lang, true);
untuk (kunci var di dalamnya)
Print(key); //Nilai kunci keluaran setiap kali

Satu faedah menggunakan Iterator() untuk mengakses objek ialah sifat tersuai yang ditambahkan pada Object.prototype tidak akan disertakan dalam objek jujukan.

Iterator() juga boleh digunakan pada tatasusunan:

Salin kod Kod adalah seperti berikut:

var langs = ['JavaScript', 'Python', 'Haskell'];
var it = Iterator(langs);
untuk (pasangan var di dalamnya)
​ print(pair); //Setiap lelaran mengeluarkan [indeks, bahasa] pasangan nilai kunci

Sama seperti melintasi objek, menghantar benar sebagai parameter kedua akan menyebabkan traversal menjadi indeks tatasusunan:

Salin kod Kod adalah seperti berikut:

var langs = ['JavaScript', 'Python', 'Haskell'];
var it = Iterator(langs, true);
untuk (var i di dalamnya)
​ print(i); //Output 0, kemudian 1, kemudian 2

Gunakan kata kunci let untuk menetapkan indeks dan nilai untuk menyekat pembolehubah di dalam gelung, dan anda juga boleh menggunakan Tugasan Pemusnahan:

Salin kod Kod adalah seperti berikut:

var langs = ['JavaScript', 'Python', 'Haskell'];
var it = Iterators(langs);
untuk (biar [i, lang] di dalamnya)
          print(i ': ' lang); //Output "0: JavaScript" dsb.

Isytiharkan lelaran tersuai

Sesetengah objek yang mewakili koleksi elemen harus diulang dengan cara yang ditentukan.

1 Mengulang objek yang mewakili julat harus mengembalikan nombor yang terkandung dalam julat satu demi satu
2. Nod daun pokok boleh diakses menggunakan depth-first atau breadth-first
3. Lelaran pada objek yang mewakili hasil pertanyaan pangkalan data harus dikembalikan baris demi baris, walaupun keseluruhan set hasil belum dimuatkan ke dalam tatasusunan tunggal
4. Peulang yang bertindak pada jujukan matematik tak terhingga (seperti jujukan Fibonacci) harus mengembalikan hasil satu demi satu tanpa mencipta struktur data panjang tak terhingga

JavaScript membolehkan anda menulis logik lelaran tersuai dan menggunakannya pada objek

Kami mencipta objek Julat mudah yang mengandungi nilai rendah dan tinggi:

Salin kod Kod adalah seperti berikut:

Julat fungsi(rendah, tinggi){
This.low = rendah;
This.high = tinggi;
}

Kini kami mencipta lelaran tersuai yang mengembalikan jujukan yang mengandungi semua integer dalam julat. Antara muka iterator memerlukan kami menyediakan kaedah next() untuk mengembalikan elemen seterusnya dalam jujukan atau membuang pengecualian StopIteration.

Salin kod Kod adalah seperti berikut:

fungsi RangeIterator(julat){
This.range = julat;
This.current = this.range.low;
}
RangeIterator.prototype.next = function(){
Jika (ini.semasa > julat.tinggi ini)
          baling Hentian Lelaran;
       lain
          kembalikan this.current ;
};

RangeIterator kami diwujudkan dengan contoh julat dan mengekalkan sifat semasa untuk menjejaki kedudukan jujukan semasa.

Akhir sekali, untuk RangeIterator digabungkan dengan Range, kita perlu menambah kaedah __iterator__ khas untuk Range. Ia akan dipanggil apabila kami cuba melelarkan Julat dan harus mengembalikan contoh RangeIterator yang melaksanakan logik lelaran.

Salin kod Kod adalah seperti berikut:

Range.prototype.__iterator__ = function(){
        kembalikan RangeIterator baharu(ini);
};

Setelah kami melengkapkan lelaran tersuai kami, kami boleh mengulangi pada julat contoh:

Salin kod Kod adalah seperti berikut:

julat var = Julat baharu(3, 5);
untuk (var i dalam julat)
​ print(i); //Output 3, kemudian 4, kemudian 5

Penjana: cara yang lebih baik untuk membina iterator

Walaupun iterator tersuai ialah alat yang berguna, perancangan yang teliti diperlukan semasa menciptanya kerana keadaan dalaman mereka perlu dikekalkan dengan jelas.

Penjana menyediakan fungsi yang sangat berkuasa: ia membolehkan anda menentukan fungsi yang mengandungi algoritma lelarannya sendiri, dan ia boleh mengekalkan keadaannya sendiri secara automatik.

Penjana ialah fungsi khas yang boleh berfungsi sebagai kilang lelaran. Jika fungsi mengandungi satu atau lebih ungkapan hasil, ia dipanggil penjana (Nota Penterjemah: Node.js juga perlu menambah * di hadapan nama fungsi untuk menunjukkannya).

Nota: Hanya blok kod yang terkandung dalam

Apabila fungsi penjana dipanggil, badan fungsi tidak akan dilaksanakan serta-merta, ia akan mengembalikan objek lelaran penjana. Setiap kali kaedah next() bagi penjana-iterator dipanggil, badan fungsi akan melaksanakan kepada ungkapan hasil seterusnya dan kemudian mengembalikan hasilnya. Apabila fungsi tamat atau kenyataan pulangan ditemui, pengecualian StopIteration dilemparkan.

Gunakan contoh untuk menerangkan dengan lebih baik:

Salin kod Kod adalah seperti berikut:

function simpleGenerator(){
menghasilkan "dahulu";
         hasil "kedua";
         menghasilkan "ketiga";
untuk (var i = 0; i           hasil i;
}
 
var g = simpleGenerator();
Print(g.next()); //Output "first"
Print(g.next()); //Output "second"
Print(g.next()); //Output "third"
Print(g.next()); //Output 0
Print(g.next()); //Output 1
Print(g.next()); //Output 2
Print(g.next()); //Throw StopIteration exception

Fungsi penjana boleh digunakan secara langsung sebagai kaedah __iterator__ oleh kelas, yang boleh mengurangkan jumlah kod yang memerlukan iterator tersuai dengan berkesan. Mari tulis semula Julat menggunakan penjana:

Salin kod Kod adalah seperti berikut:

Julat fungsi(rendah, tinggi){
This.low = rendah;
This.high = tinggi;
}
Range.prototype.__iterator__ = function(){
untuk (var i = this.low; i           hasil i;
};
julat var = Julat baharu(3, 5);
untuk (var i dalam julat)
​ print(i); //Output 3, kemudian 4, kemudian 5

Tidak semua penjana ditamatkan, anda boleh mencipta penjana yang mewakili urutan tak terhingga. Penjana berikut melaksanakan jujukan Fibonacci, di mana setiap elemen ialah hasil tambah dua sebelumnya:

Salin kod Kod adalah seperti berikut:

fungsi fibonacci(){
var fn1 = 1;
var fn2 = 1;
manakala (1) {
        var semasa = fn2;
           fn2 = fn1;
             fn1 = arus fn1;
                        hasil semasa;
}
}
 
jujukan var = fibonacci();
Print(sequence.next()); // 1
Print(sequence.next()); // 1
Print(sequence.next()); // 2
Print(sequence.next()); // 3
Print(sequence.next()); // 5
Print(sequence.next()); // 8
Print(sequence.next()); // 13

Generatorfunktionen können Parameter annehmen, und diese Parameter werden beim ersten Aufruf der Funktion verwendet. Mit der return-Anweisung kann ein Generator beendet werden (was dazu führt, dass er eine StopIteration-Ausnahme auslöst). Die folgende Variante von fibonacci() verwendet ein optionales Limit-Argument, das die Funktion beendet, wenn eine Bedingung ausgelöst wird.

Code kopieren Der Code lautet wie folgt:

Funktion fibonacci(limit){
var fn1 = 1;
var fn2 = 1;
while(1){
        var current = fn2;
           fn2 = fn1;
             fn1 = fn1 aktuell;
Wenn (Limit && aktuelles > Limit)
           zurück;
                        Ertrag aktuell;
}
}

Erweiterte Generatorfunktionen

Der Generator kann den Yield-Return-Wert bei Bedarf berechnen, was es ermöglicht, zuvor teure Sequenzberechnungsanforderungen darzustellen, sogar unendliche Sequenzen, wie oben gezeigt.

Zusätzlich zur next()-Methode verfügt das Generator-Iterator-Objekt auch über eine send()-Methode, die den internen Status des Generators ändern kann. Der an send() übergebene Wert wird als Ergebnis des letzten Yield-Ausdrucks behandelt und der Generator wird angehalten. Bevor Sie die send()-Methode verwenden, um einen bestimmten Wert zu übergeben, müssen Sie next() mindestens einmal aufrufen, um den Generator zu starten.

Der folgende Fibonacci-Generator verwendet die send()-Methode, um die Sequenz neu zu starten:

Code kopieren Der Code lautet wie folgt:

Funktion fibonacci(){
var fn1 = 1;
var fn2 = 1;
während (1) {
        var current = fn2;
           fn2 = fn1;
             fn1 = fn1 aktuell;
      var reset = Ertragsstrom;
          if (zurücksetzen) {
              fn1 = 1;
              fn2 = 1;
}
}
}
 
var sequence = fibonacci();
Print(sequence.next()); //1
Print(sequence.next()); //1
Print(sequence.next()); //2
Print(sequence.next()); //3
Print(sequence.next()); //5
Print(sequence.next()); //8
Print(sequence.next()); //13
Print(sequence.send(true)); //1
Print(sequence.next()); //1
Print(sequence.next()); //2
Print(sequence.next()); //3

Hinweis: Ein interessanter Punkt ist, dass der Aufruf von send(undefiniert) genau das Gleiche ist wie der Aufruf von next(). Wenn jedoch die Methode send() aufgerufen wird, um einen neuen Generator zu starten, löst jeder andere Wert als undefiniert eine TypeError-Ausnahme aus.

Sie können einen Generator dazu zwingen, eine Ausnahme auszulösen, indem Sie die Methode throw aufrufen und einen Ausnahmewert übergeben, den er auslösen soll. Diese Ausnahme wird aus dem aktuellen Kontext ausgelöst und hält den Generator an, ähnlich der aktuellen Yield-Ausführung, mit der Ausnahme, dass sie durch eine Throw-Value-Anweisung ersetzt wird.

Wenn Yield während der Behandlung einer ausgelösten Ausnahme nicht auftritt, wird die Ausnahme weitergegeben, bis die Methode throw() aufgerufen wird, und nachfolgende Aufrufe von next() führen dazu, dass die StopIteration-Ausnahme ausgelöst wird.

Generatoren verfügen über eine close()-Methode, um das Beenden des Generators zu erzwingen. Das Beenden eines Generators hat folgende Auswirkungen:

1. Alle gültigen Final-Klauseln im Generator werden ausgeführt
2. Wenn die final-Klausel eine andere Ausnahme als StopIteration auslöst, wird die Ausnahme an den Aufrufer der close()-Methode
übergeben 3. Der Generator wird beendet

Generatorausdruck

Ein offensichtlicher Nachteil von Array-Comprehensions besteht darin, dass sie dazu führen, dass das gesamte Array im Speicher erstellt wird. Der Mehraufwand ist trivial, wenn die Eingabe für das Verständnis ein kleines Array ist – es können jedoch Probleme auftreten, wenn das Eingabearray groß ist oder wenn ein neuer teurer (oder unendlicher) Array-Generator erstellt wird.

Generatoren ermöglichen die verzögerte Berechnung von Sequenzen und berechnen Elemente bei Bedarf nach Bedarf. Ein Generatorausdruck ist syntaktisch fast dasselbe wie ein Array-Verständnis – er verwendet Klammern anstelle von eckigen Klammern (und for...in statt for every...in) –, erstellt jedoch einen Generator anstelle eines Arrays, sodass Sie dies können die Berechnung verzögern. Sie können es sich als eine kurze Syntax zum Erstellen von Generatoren vorstellen.

Angenommen, wir haben einen Iterator, der eine große Folge von ganzen Zahlen durchläuft. Wir müssen einen neuen Iterator erstellen, um über gerade Zahlen zu iterieren. Ein Array-Verständnis erstellt ein vollständiges Array aller geraden Zahlen im Speicher:

Code kopieren Der Code lautet wie folgt:

var doubles = [i * 2 for (i in it)];

Der Generatorausdruck erstellt einen neuen Iterator und berechnet bei Bedarf bei Bedarf gerade Werte:

Code kopieren Der Code lautet wie folgt:

var it2 = (i * 2 for (i in it));
Print(it2.next()); //Die erste gerade Zahl darin
Print(it2.next()); //Die zweite gerade Zahl darin

Wenn ein Generator als Funktionsargument verwendet wird, werden für Funktionsaufrufe Klammern verwendet, d. h. die äußersten Klammern können weggelassen werden:

Code kopieren Der Code lautet wie folgt:

var result = doSomething(i * 2 for (i in it));

Ende.