Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Iteratory i protokół iterowalny
W tej lekcji8
W laboratorium genetycznym Parku Jurajskiego, Dr. Henry Wu przegląda ogromne zbiory danych DNA dinozaurów. "Potrzebujemy sposobu, aby przetwarzać sekwencje genetyczne element po elemencie, bez ładowania całej bazy do pamięci," mówi. Pętla for...of radzi sobie z tablicą od ręki, ale przepuść przez nią zwykły obiekt parku z sektorami, a dostaniesz TypeError z informacją, że obiekt nie jest iterowalny. Na szczęście JavaScript oferuje iteratory i protokół iterowalny - mechanizmy, które pozwalają kontrolować sposób przeglądania kolekcji danych.
Czym jest iterator?
Iterator to obiekt, który wie, jak uzyskać dostęp do elementów kolekcji po jednym naraz, śledząc swoją aktualną pozycję. Iterator musi implementować metodę next(), która zwraca obiekt z dwoma właściwościami:
value- aktualna wartośćdone-truejeśli nie ma więcej elementów,falsew przeciwnym przypadku
// Prosty iterator - ręcznie stworzony
function createDinoIterator(dinosaurs) {
let index = 0;
return {
next() {
if (index < dinosaurs.length) {
return { value: dinosaurs[index++], done: false };
}
return { value: undefined, done: true };
}
};
}
const raptorIterator = createDinoIterator(["Blue", "Charlie", "Delta", "Echo"]);
console.log(raptorIterator.next()); // { value: "Blue", done: false }
console.log(raptorIterator.next()); // { value: "Charlie", done: false }
console.log(raptorIterator.next()); // { value: "Delta", done: false }
console.log(raptorIterator.next()); // { value: "Echo", done: false }
console.log(raptorIterator.next()); // { value: undefined, done: true }Zmienna index żyje w domknięciu i pamięta pozycję między wywołaniami next(). Po ostatnim raptorze iterator zgłasza done: true i odpowiada tak już zawsze - nie zaczyna od nowa. Przekazana tablica nie zmieniła się ani trochę.
Protokół iterowalny (Symbol.iterator)
Aby obiekt mógł być użyty w pętli for...of, musi implementować protokół iterowalny - czyli posiadać metodę [Symbol.iterator](), która zwraca iterator. Wiele wbudowanych typów już to implementuje: Array, String, Map, Set.
// Tablice są iterowalne
const species = ["T-Rex", "Velociraptor", "Triceratops"];
for (const dino of species) {
console.log(dino);
}
// T-Rex
// Velociraptor
// Triceratops
// Stringi też są iterowalne
for (const char of "DINO") {
console.log(char); // D, I, N, O
}
// Możemy ręcznie pobrać iterator z tablicy
const iterator = species[Symbol.iterator]();
console.log(iterator.next()); // { value: "T-Rex", done: false }
console.log(iterator.next()); // { value: "Velociraptor", done: false }Pętla for...of robi za kulisami to, co widać w ostatnich liniach: pobiera iterator przez Symbol.iterator i woła next(), aż zobaczy done: true. Symbol.iterator to wbudowany symbol, czyli unikalny klucz, którego nie pomylisz ze zwykłą nazwą właściwości. Literał obiektu takiej metody nie ma i stąd błąd z wprowadzenia.
Tworzenie własnego obiektu iterowalnego
Możemy sprawić, by dowolny obiekt był iterowalny - wystarczy zdefiniować metodę [Symbol.iterator](). Nasz park przejdzie przez wszystkie sektory, oddając po jednym dinozaurze:
// Park Jurajski jako obiekt iterowalny
const jurassicPark = {
name: "Jurassic Park",
sectors: [
{ id: "A", dinosaurs: ["Rexy", "Blue"] },
{ id: "B", dinosaurs: ["Spike", "Trike"] },
{ id: "C", dinosaurs: ["Pteranodon", "Mosasaurus"] }
],
// Implementacja protokołu iterowalnego
[Symbol.iterator]() {
let sectorIndex = 0;
let dinoIndex = 0;
const sectors = this.sectors;
return {
next() {
// Przechodzimy przez wszystkie dinozaury we wszystkich sektorach
while (sectorIndex < sectors.length) {
const sector = sectors[sectorIndex];
if (dinoIndex < sector.dinosaurs.length) {
const value = {
sector: sector.id,
dinosaur: sector.dinosaurs[dinoIndex]
};
dinoIndex++;
return { value, done: false };
}
sectorIndex++;
dinoIndex = 0;
}
return { value: undefined, done: true };
}
};
}
};
// Teraz możemy iterować po parku!
for (const entry of jurassicPark) {
console.log(`Sektor ${entry.sector}: ${entry.dinosaur}`);
}
// Sektor A: Rexy
// Sektor A: Blue
// Sektor B: Spike
// Sektor B: Trike
// Sektor C: Pteranodon
// Sektor C: Mosasaurus
// Działa też spread operator i destrukturyzacja
const allDinos = [...jurassicPark];
console.log(allDinos.length); // 6Nawiasy kwadratowe przy nazwie metody oznaczają, że kluczem jest symbol, a nie tekst. Pętla while w next() przeskakuje do kolejnego sektora, gdy w bieżącym zabraknie dinozaurów, więc na zewnątrz widać jedną płaską listę. Dane w sectors zostają nietknięte - iterator tylko je czyta.
Generatory jako iteratory
Ręczne pisanie next() jest żmudne. Generatory to specjalne funkcje oznaczone gwiazdką (function*), które upraszczają tworzenie iteratorów. Używają słowa kluczowego yield do "wyprodukowania" kolejnych wartości:
// Generator sekwencji DNA
function* dnaSequenceGenerator(sequence) {
for (const nucleotide of sequence) {
yield nucleotide;
}
}
const dna = dnaSequenceGenerator("ATCGATCG");
console.log(dna.next()); // { value: "A", done: false }
console.log(dna.next()); // { value: "T", done: false }
console.log(dna.next()); // { value: "C", done: false }
// Generatory są iterowalne - działają z for...of
for (const nucleotide of dnaSequenceGenerator("GCTA")) {
console.log(nucleotide); // G, C, T, A
}Wywołanie generatora nie uruchamia jeszcze jego ciała, tylko zwraca obiekt generatora. Każde next() wykonuje kod do najbliższego yield i tam go wstrzymuje, pamiętając stan. Gwiazdka stoi przy słowie function, nie przy nazwie - zapis function myGen*() jest błędem składni.
Generator z logiką
Generator może produkować wartości bez końca, bo liczy każdą dopiero wtedy, gdy ktoś o nią poprosi. Tak działa maszyna nadająca identyfikatory:
// Generator identyfikatorów dinozaurów
function* dinoIdGenerator(prefix, startFrom = 1) {
let id = startFrom;
while (true) {
yield `${prefix}-${String(id).padStart(3, "0")}`;
id++;
}
}
const raptorIds = dinoIdGenerator("RAPTOR");
console.log(raptorIds.next().value); // "RAPTOR-001"
console.log(raptorIds.next().value); // "RAPTOR-002"
console.log(raptorIds.next().value); // "RAPTOR-003"
// Generator nieskończony - ale pobieramy tylko tyle ile potrzebujemy
const trexIds = dinoIdGenerator("TREX", 100);
const firstFive = [];
for (let i = 0; i < 5; i++) {
firstFive.push(trexIds.next().value);
}
console.log(firstFive);
// ["TREX-100", "TREX-101", "TREX-102", "TREX-103", "TREX-104"]Pętla while (true) nie zawiesza programu, bo generator pracuje leniwie: zatrzymuje się na yield i czeka na kolejne next(). Nigdy jednak nie rozwijaj nieskończonego generatora spreadem - takie wywołanie nie ma końca. Metoda padStart(3, "0") dopełnia numer zerami do trzech cyfr.
Praktyczny przykład: Stronicowanie danych
Iteratory świetnie nadają się do stronicowania (paginacji) dużych zbiorów danych, bo każda strona powstaje dopiero na żądanie:
// Generator stron z danymi o dinozaurach
function* paginateDinosaurs(dinosaurs, pageSize) {
for (let i = 0; i < dinosaurs.length; i += pageSize) {
yield {
page: Math.floor(i / pageSize) + 1,
data: dinosaurs.slice(i, i + pageSize),
hasMore: i + pageSize < dinosaurs.length
};
}
}
const allDinosaurs = [
"T-Rex", "Velociraptor", "Triceratops", "Stegosaurus",
"Brachiosaurus", "Pteranodon", "Mosasaurus", "Dilophosaurus",
"Gallimimus", "Parasaurolophus"
];
const pages = paginateDinosaurs(allDinosaurs, 3);
console.log(pages.next().value);
// { page: 1, data: ["T-Rex", "Velociraptor", "Triceratops"], hasMore: true }
console.log(pages.next().value);
// { page: 2, data: ["Stegosaurus", "Brachiosaurus", "Pteranodon"], hasMore: true }
console.log(pages.next().value);
// { page: 3, data: ["Mosasaurus", "Dilophosaurus", "Gallimimus"], hasMore: true }
console.log(pages.next().value);
// { page: 4, data: ["Parasaurolophus"], hasMore: false }Każde next() oddaje porcję trzech gatunków i flagę hasMore, która mówi, czy prosić o kolejną. Ostatnia strona ma jeden element, bo slice() nie wychodzi poza koniec tablicy.
Obiekt iterowalny z generatorem
Generatory upraszczają tworzenie obiektu iterowalnego. Zamiast ręcznie składać obiekt z metodą next(), wystarczy oznaczyć gwiazdką metodę [Symbol.iterator]:
class DinosaurEnclosure {
constructor(name) {
this.name = name;
this.dinosaurs = [];
}
add(dinosaur) {
this.dinosaurs.push(dinosaur);
}
// Generator jako Symbol.iterator - znacznie prostsze!
*[Symbol.iterator]() {
for (const dino of this.dinosaurs) {
yield dino;
}
}
}
const paddock = new DinosaurEnclosure("Raptor Paddock");
paddock.add({ name: "Blue", species: "Velociraptor" });
paddock.add({ name: "Charlie", species: "Velociraptor" });
paddock.add({ name: "Delta", species: "Velociraptor" });
for (const raptor of paddock) {
console.log(`Raptor: ${raptor.name}`);
}
// Raptor: Blue
// Raptor: Charlie
// Raptor: Delta
// Spread operator działa automatycznie
const names = [...paddock].map(r => r.name);
console.log(names); // ["Blue", "Charlie", "Delta"]Porównaj to z parkiem z wcześniejszej sekcji: tam kilkanaście linijek z indeksami, tutaj trzy. Obiekt generatora sam spełnia oba protokoły naraz, więc klasa od razu działa z for...of i ze spreadem.
Destrukturyzacja i spread
Z protokołu iterowalnego korzystają też spread i destrukturyzacja tablic - obie weszły do języka w ES6 (ES2015), podobnie jak destrukturyzacja obiektów:
const raptors = ["Blue", "Charlie", "Delta", "Echo"];
// Destrukturyzacja tablicy - kolejne wartości z iteratora
const [first, second, third] = raptors;
console.log(first, second, third); // Blue Charlie Delta
// Spread - łączenie tablic
const newcomers = ["Fox", "Ghost"];
const allRaptors = [...raptors, ...newcomers];
console.log(allRaptors.length); // 6
// Destrukturyzacja i spread obiektu - bez iteratorów
const raptor = { name: "Blue", age: 4, isAlpha: true };
const { name, age, isAlpha } = raptor;
const olderBlue = { ...raptor, age: 5 };
console.log(name, age, isAlpha, olderBlue.age); // Blue 4 true 5Destrukturyzacja tablicy pobiera wartości kolejno z iteratora, dlatego zadziała też z parkiem czy generatorem. Obiekty to inna historia: destrukturyzacja obiektu sięga po właściwości według nazw, a spread obiektu, dodany w ES2018, kopiuje jego własne pola - żadne z nich nie używa Symbol.iterator. Kopia jest płytka, a oryginalny raptor nadal ma 4 lata.
Podsumowanie
Dr. Wu podsumowuje: "Iteratory to jak specjalistyczne sondy genetyczne - pozwalają przeglądać dane sekwencyjnie, krok po kroku:"
- Iterator - obiekt z metodą
next()zwracającą{ value, done } - Symbol.iterator - metoda, która czyni obiekt iterowalnym (działa z
for...of) - Generatory (
function*+yield) - upraszczają tworzenie iteratorów - Protokół iterowalny - umowa, że obiekt można iterować, używana przez
for...of, spread (...) i destrukturyzację
W codziennym kodzie polecam generator zamiast ręcznego next() - jest krótszy i trudniej w nim o błąd. Spread wróci w tej lokacji we wzorcu Builder, gdzie metoda build() oddaje kopię obiektu. W laboratorium poniżej zbudujesz klasę DinosaurEnclosure z generatorem jako Symbol.iterator.
Pamiętaj: iterator to sonda, która czyta próbki DNA po jednej, a Symbol.iterator to gniazdo, do którego pasuje każda pętla for...of.
Kod do tej lekcji: index.js
// Iteratory i protokol iterowalny
// Park Jurajski - Laboratorium genetyczne
console.log("=== ITERATOR RECZNY ===");
// Tworzenie prostego iteratora
function createDinoIterator(dinosaurs) {
let index = 0;
return {
next() {
if (index < dinosaurs.length) {
return { value: dinosaurs[index++], done: false };
}
return { value: undefined, done: true };
}
};
}
const raptorIterator = createDinoIterator(["Blue", "Charlie", "Delta", "Echo"]);
console.log(raptorIterator.next()); // { value: "Blue", done: false }
console.log(raptorIterator.next()); // { value: "Charlie", done: false }
console.log(raptorIterator.next()); // { value: "Delta", done: false }
console.log(raptorIterator.next()); // { value: "Echo", done: false }
console.log(raptorIterator.next()); // { value: undefined, done: true }
console.log("\n=== SYMBOL.ITERATOR ===");
// Obiekt iterowalny z Symbol.iterator
const jurassicPark = {
sectors: [
{ id: "A", dinosaurs: ["Rexy", "Blue"] },
{ id: "B", dinosaurs: ["Spike", "Trike"] },
],
[Symbol.iterator]() {
let sectorIndex = 0;
let dinoIndex = 0;
const sectors = this.sectors;
return {
next() {
while (sectorIndex < sectors.length) {
const sector = sectors[sectorIndex];
if (dinoIndex < sector.dinosaurs.length) {
const value = {
sector: sector.id,
dinosaur: sector.dinosaurs[dinoIndex]
};
dinoIndex++;
return { value, done: false };
}
sectorIndex++;
dinoIndex = 0;
}
return { value: undefined, done: true };
}
};
}
};
// for...of dziala dzieki Symbol.iterator
for (const entry of jurassicPark) {
console.log(`Sektor ${entry.sector}: ${entry.dinosaur}`);
}
// Spread operator tez dziala
const allDinos = [...jurassicPark];
console.log("Wszystkie dinozaury:", allDinos);
console.log("\n=== GENERATORY ===");
// Generator - uproszczony sposob tworzenia iteratorow
function* dinoIdGenerator(prefix, startFrom = 1) {
let id = startFrom;
while (true) {
yield `${prefix}-${String(id).padStart(3, "0")}`;
id++;
}
}
const raptorIds = dinoIdGenerator("RAPTOR");
console.log(raptorIds.next().value); // "RAPTOR-001"
console.log(raptorIds.next().value); // "RAPTOR-002"
console.log(raptorIds.next().value); // "RAPTOR-003"
// Generator stronicowania
function* paginateDinosaurs(dinosaurs, pageSize) {
for (let i = 0; i < dinosaurs.length; i += pageSize) {
yield {
page: Math.floor(i / pageSize) + 1,
data: dinosaurs.slice(i, i + pageSize),
hasMore: i + pageSize < dinosaurs.length
};
}
}
const allSpecies = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus",
"Brachiosaurus", "Pteranodon", "Mosasaurus", "Dilophosaurus"];
const pages = paginateDinosaurs(allSpecies, 3);
console.log("\nStronicowanie:");
console.log(pages.next().value);
console.log(pages.next().value);
console.log(pages.next().value);
// TODO: Stworz klase DinosaurEnclosure z generatorem jako Symbol.iterator
// Klasa powinna miec metode add() i byc iterowalna
console.log("\n=== Cwiczenie ===");
console.log("Stworz klase DinosaurEnclosure - patrz TODO w kodzie");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jaki obiekt musi zwracać metoda next() iteratora w JavaScript?
2. Co musi implementować obiekt, aby można go było użyć w pętli for...of?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Użyj array destructuring do przypisania pierwszych trzech Velociraptorów do zmiennych.
- Edytor kodu
Wyciągnij name, age i isAlpha z obiektu raptor używając destructuring.
- Edytor kodu
Połącz dwie grupy Velociraptorów używając spread operator.
- Układanie w pionie
Uporządkuj wzorce projektowe obiektów od prostych do złożonych:
- Edytor kodu
Stwórz metody hunt(), communicate() i followPack() w obiekcie raptor.
- Edytor kodu
Stwórz obiekt paddock zawierający tablicę raptors i metody zarządzania.
- Układanie w pionie
Uporządkuj nowoczesne funkcje JavaScript chronologicznie według standardu:
- Układanie w pionie
Uporządkuj zarządzanie pamięcią dla obiektów i tablic:
- Edytor kodu
Stwórz zmienną przechowującą gatunek dinozaura
- Układanie w pionie
Uporządkuj proces wyboru struktury danych:
- Edytor kodu
Napisz funkcję obliczającą wiek skamieniałości
Zadania po tej lekcji
- PytanieProtokół iteratora
- PytanieSymbol.iterator i for...of
- Zadanie z kodemĆwiczenie: Destrukturyzacja tablic
- PytanieGeneratory w JavaScript
- PytanieSkładnia generatora
- Zadanie z kodemĆwiczenie: Destrukturyzacja obiektów
- Zadanie z kodemĆwiczenie: Operator spread
- Ułóż w kolejnościWzorce projektowe obiektów
- Zadanie z kodemMetody raptora
- Zadanie z kodemZłożone struktury danych
- Ułóż w kolejnościNowoczesne funkcje JavaScript
- Ułóż w kolejnościProces zarządzania pamięcią
- Zadanie z kodemĆwiczenie: Deklaracja zmiennej z typem gatunku dinozaura
- Ułóż w kolejnościWybór struktury danych
- Zadanie z kodemĆwiczenie: Funkcja obliczająca wiek skamieniałości na podstawie warstw geologicznych