JavaScripti Generaatori Protokolli Laiendus: Täiustatud iteraatoriliidese Valitsemine

JavaScripti dünaamilises maailmas on tõhus andmetöötlus ja juhtimisvoo haldamine esmatähtsad. Kaasaegsed rakendused tegelevad pidevalt andmevoogude, asünkroonsete toimingute ja keerukate järjestustega, nõudes vastupidavaid ja elegantseid lahendusi. See põhjalik juhend sukeldub JavaScripti generaatorite põnevasse valdkonda, keskendudes eelkõige nende protokollilaiendustele, mis tõstavad tagasihoidliku iteraatori võimsaks, mitmekülgseks tööriistaks. Uurime, kuidas need täiustused annavad arendajatele võimaluse luua väga tõhusaid, koostatavaid ja loetavaid koode paljudeks keerukateks stsenaariumideks, alates andmepipeliinidest kuni asünkroonsete töövoogudeni.

Enne kui asume sellele teekonnale arenenud generaatorite võimete juurde, vaatame lühidalt üle JavaScripti iteraatorite ja itereeritavate objektide põhialused. Nende põhiliste ehitusplokkide mõistmine on otsustava tähtsusega generaatorite poolt pakutava keerukuse hindamiseks.

Põhialused: JavaScripti itereeritavad objektid ja iteraatorid

Oma olemuselt pöörleb JavaScripti iteratsiooni kontseptsioon kahe põhilise protokolli ümber:

• Itereeritav protokoll: Määratleb, kuidas objekti saab itereerida for...of silmusega. Objekti on itereeritav, kui sellel on meetod nimega [Symbol.iterator], mis tagastab iteraatori.
• Iteraatori protokoll: Määratleb, kuidas objekt toodab väärtuste jada. Objekt on iteraator, kui sellel on meetod next(), mis tagastab objekti kahe omadusega: value (järjestuse järgmine üksus) ja done (tühik, mis näitab, kas järjestus on lõppenud).

Itereeritava protokolli mõistmine (Symbol.iterator)

Iga objekti, millel on [Symbol.iterator] võtme kaudu juurdepääsetav meetod, peetakse itereeritavaks. See meetod peab selle kutsumisel tagastama iteraatori. Sisseehitatud tüübid nagu massiivid, stringid, Mapid ja Setid on kõik loomulikult itereeritavad.

Vaatame lihtsat massiivi:

            const myArray = [1, 2, 3];
const iterator = myArray[Symbol.iterator]();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

            

              
                Copy
              
            
          

for...of silmus kasutab seda protokolli sisemiselt väärtuste itereerimiseks. See kutsub korraks automaatselt [Symbol.iterator](), et saada iteraator, ja seejärel kutsub korduvalt next(), kuni done muutub true.

Iteraatori protokolli mõistmine (next(), value, done)

Iteraatori protokolli järgiv objekt pakub meetodit next(). Iga next() kutse tagastab objekti kahe peamise omadusega:

• value: Järjestuse tegelik andmeüksus. See võib olla mis tahes JavaScripti väärtus.
• done: Tühik. false näitab, et toodetakse rohkem väärtusi; true näitab, et iteratsioon on lõppenud ja value on sageli undefined (kuigi see võib tehniliselt olla mis tahes lõplik tulemus).

Iteraatori käsitsi rakendamine võib olla liiga palju sõnu:

            function createRangeIterator(start, end) {
    let current = start;
    return {
        next() {
            if (current <= end) {
                return { value: current++, done: false };
            } else {
                return { value: undefined, done: true };
            }
        }
    };
}

const range = createRangeIterator(1, 3);
console.log(range.next()); // { value: 1, done: false }
console.log(range.next()); // { value: 2, done: false }
console.log(range.next()); // { value: 3, done: false }
console.log(range.next()); // { value: undefined, done: true }

            

              
                Copy
              
            
          

Generaatorid: Iteraatorite loomise lihtsustamine

Siin generaatorid säravad. ECMAScript 2015 (ES6) abil tutvustatud generaatorfunktsioonid (defineeritud function* abil) pakuvad palju ergonoomilisemat viisi iteraatorite kirjutamiseks. Kui generaatorfunktsiooni kutsutakse, ei täida see oma keha kohe; selle asemel tagastab see Generaatori Objekti. See objekt ise vastab nii itereeritavate kui ka iteraatorite protokollidele.

Maagia juhtub yield võtmesõnaga. Kui yield on kohanud, peatub generaator täitmist, tagastab saadud väärtuse ja salvestab oma oleku. Kui generaatori objektile kutsutakse uuesti next(), jätkub täitmine sealt, kus see pooleli jäi, kuni järgmise yield või funktsiooni keha lõpuni.

Lihtne Generaatori Näide

Kirjutame meie createRangeIterator generaatori abil uuesti:

            function* rangeGenerator(start, end) {
    for (let i = start; i <= end; i++) {
        yield i;
    }
}

const myRange = rangeGenerator(1, 3);
console.log(myRange.next()); // { value: 1, done: false }
console.log(myRange.next()); // { value: 2, done: false }
console.log(myRange.next()); // { value: 3, done: false }
console.log(myRange.next()); // { value: undefined, done: true }

// Generaatorid on ka itereeritavad, nii et saate kasutada otse for...of:
console.log("Kasutades for...of:");
for (const num of rangeGenerator(4, 6)) {
    console.log(num); // 4, 5, 6
}

            

              
                Copy
              
            
          

Märka, kui palju puhtam ja intuitiivsem on generaatori versioon võrreldes käsitsi iteraatori rakendusega. See põhivõimekus üksi muudab generaatorid uskumatult kasulikuks. Kuid seal on rohkem – palju rohkem – nende võimsusest, eriti kui me sukeldume nende protokollilaiendustesse.

Täiustatud iteraatoriliides: Generaatori protokollilaiendused

Generaatori protokolli laienduse osa viitab võimetele, mis ületavad lihtsalt väärtuste saamist. Need täiustused pakuvad mehhanisme suuremaks juhtimiseks, koostamiseks ja suhtluseks generaatorite sees ja nende kutsujate vahel. Konkreetselt uurime yield* delegeerimise jaoks, väärtuste saatmist generaatoritesse tagasi ning generaatorite graafilist või veaga lõpetamist.

1. yield*: Deklaratsioon teistele itereeritavatele objektidele

yield* (yield-star) väljend on võimas funktsioon, mis võimaldab generaatoril delegeerida teisele itereeritavale objektile. See tähendab, et see võib tõhusalt "saada kõik" väärtused teisest itereeritavast objektist, peatades oma täitmise, kuni delegeeritud itereeritav objekt on ammendatud. See on uskumatult kasulik keerukate iteratsioonimustrite koostamiseks lihtsamatest, edendades modulaarsust ja taaskasutatavust.

Kuidas yield* töötab

Kui generaator kohtab yield* iterable, teeb see järgmist:

1. See hangib iteraatori iterable objektist.
2. Seejärel hakkab saama iga väärtust, mida see sisemine iteraator toodab.
3. Mis tahes väärtus, mis saadetakse tagasi delegeerivasse generaatorisse selle next() meetodi kaudu, edastatakse delegeeritud iteraatori next() meetodile.
4. Kui delegeeritud iteraator viskab vea, visatakse see viga tagasi delegeerivasse generaatorisse.
5. Oluline on see, et kui delegeeritud iteraator lõpetab (selle next() tagastab { done: true, value: X }), muutub väärtus X yield* väljendi tagastusväärtuseks delegeerivas generaatoris. See võimaldab sisemistel iteraatoritel lõpptulemuse tagastada.

Praktiline Näide: Iteratsioonijärjestuste kombineerimine

            function* naturalNumbers() {
    yield 1;
    yield 2;
    yield 3;
}

function* evenNumbers() {
    yield 2;
    yield 4;
    yield 6;
}

function* combinedNumbers() {
    console.log("Alustatakse loomulikke numbreid...");
    yield* naturalNumbers(); // Deklareerib naturalNumbers generaatori juurde
    console.log("Lõpetatud loomulike numbritega, alustatakse paarisnumbritega...");
    yield* evenNumbers();    // Deklareerib evenNumbers generaatori juurde
    console.log("Kõik numbrid on töödeldud.");
}

const combined = combinedNumbers();

for (const num of combined) {
    console.log(num);
}
// Väljund:
// Alustatakse loomulikke numbreid...
// 1
// 2
// 3
// Lõpetatud loomulike numbritega, alustatakse paarisnumbritega...
// 2
// 4
// 6
// Kõik numbrid on töödeldud.

            

              
                Copy
              
            
          

Nagu näete, ühendab yield* sujuvalt naturalNumbers ja evenNumbers väljundi üheks pidevaks järjestuseks, samal ajal kui delegeeriv generaator haldab üldist voogu ja võib delegeeritud järjestuste ümber lisada täiendavat loogikat või sõnumeid.

yield* koos Tagastusväärtustega

Üks yield* kõige võimsamaid aspekte on selle võime jäädvustada delegeeritud iteraatori lõplik tagastusväärtus. Generaator võib väärtuse tagastada selgesõnaliselt return avaldisega. See väärtus jäädvustatakse viimase next() kutse value atribuudiga, aga ka yield* väljendiga, kui see delegeerib sellele generaatorile.

            function* processData(data) {
    let sum = 0;
    for (const item of data) {
        sum += item;
        yield item * 2; // Saada töödeldud üksus
    }
    return sum; // Tagasta algandmete summa
}

function* analyzePipeline(rawData) {
    console.log("Alustatakse andmete töötlemist...");
    // yield* jäädvustab processData tagastusväärtuse
    const totalSum = yield* processData(rawData);
    console.log(`Algandmete summa: ${totalSum}`);
    yield "Töötlemine lõpetatud!";
    return `Lõplik summa on teatatud: ${totalSum}`;
}

const pipeline = analyzePipeline([10, 20, 30]);

let result = pipeline.next();
while (!result.done) {
    console.log(`Pipeliini väljund: ${result.value}`);
    result = pipeline.next();
}
console.log(`Lõplik pipeliini tulemus: ${result.value}`);

// Oodatav Väljund:
// Alustatakse andmete töötlemist...
// Pipeliini väljund: 20
// Pipeliini väljund: 40
// Pipeliini väljund: 60
// Algandmete summa: 60
// Pipeliini väljund: Töötlemine lõpetatud!
// Lõplik pipeliini tulemus: Lõplik summa on teatatud: 60

            

              
                Copy
              
            
          

Siin mitte ainult ei saada processData teisendatud väärtusi, vaid tagastab ka algandmete summa. analyzePipeline kasutab yield* teisendatud väärtuste tarbimiseks ja samal ajal selle summa jäädvustamiseks, võimaldades delegeerival generaatoril reageerida või kasutada delegeeritud toimingu lõpptulemust.

Täiustatud Kasutusjuhtum: Puude läbikäimine

yield* on suurepärane rekursiivsete struktuuride nagu puude jaoks.

            class TreeNode {
    constructor(value) {
        this.value = value;
        this.children = [];
    }

    addChild(node) {
        this.children.push(node);
    }

    // Muudab sõlme itereeritavaks sügavuti läbikäimiseks
    *[Symbol.iterator]() {
        yield this.value; // Saada praeguse sõlme väärtus
        for (const child of this.children) {
            yield* child; // Deklareerib lastele nende läbikäimiseks
        }
    }
}

const root = new TreeNode('A');
const nodeB = new TreeNode('B');
const nodeC = new TreeNode('C');
const nodeD = new TreeNode('D');
const nodeE = new TreeNode('E');

root.addChild(nodeB);
root.addChild(nodeC);
nodeB.addChild(nodeD);
nodeC.addChild(nodeE);

console.log("Puude läbikäimine (sügavuti):");
for (const val of root) {
    console.log(val);
}
// Väljund:
// Puude läbikäimine (sügavuti):
// A
// B
// D
// C
// E

            

              
                Copy
              
            
          

See rakendab elegantselt sügavuti läbikäimise, kasutades yield*, näidates selle võimsust rekursiivsete iteratsioonimustrite jaoks.

2. Väärtuste saatmine generaatorisse: next() meetod argumentidega

Üks silmapaistvamaid "protokollilaiendusi" generaatoritele on nende kahesuunaline suhtlusvõime. Kui yield saadab väärtusi välja generaatorist, võib meetod next() vastu võtta ka argumendi, võimaldades teil saata väärtusi tagasi peatatud generaatorisse. See muudab generaatorid lihtsatest andmetootjatest võimsateks korutiini-laadseteks ehitisteks, mis suudavad peatuda, sisendit vastu võtta, töödelda ja jätkata.

Kuidas see töötab

Kui kutsute generatorObject.next(valueToInject), muutub valueToInject selle yield väljendi tulemuseks, mis põhjustas generaatori peatumise. Kui generaator ei peatunud yield poolt (nt. see oli just alustatud või oli lõpetatud), ignoreeritakse sisestatud väärtust.

            function* interactiveProcess() {
    const input1 = yield "Palun sisestage esimene number:";
    console.log(`Vastuvõetud esimene number: ${input1}`);

    const input2 = yield "Nüüd sisestage teine number:";
    console.log(`Vastuvõetud teine number: ${input2}`);

    const sum = Number(input1) + Number(input2);
    yield `Summa on: ${sum}`;
    return "Protsess lõpetatud.";
}

const process = interactiveProcess();

// Esimene next() kõne käivitab generaatori, argument ignoreeritakse.
// See saabub esimese viipena.
let response = process.next();
console.log(response.value); // Palun sisestage esimene number:

// Saada esimene number tagasi generaatorisse
response = process.next(10);
console.log(response.value); // Nüüd sisestage teine number:

// Saada teine number tagasi
response = process.next(20);
console.log(response.value); // Summa on: 30

// Lõpetage protsess
response = process.next();
console.log(response.value); // Protsess lõpetatud.
console.log(response.done);  // true

            

              
                Copy
              
            
          

See näide demonstreerib selgelt, kuidas generaator peatub, küsib sisendit ja seejärel saab selle sisendi oma täitmise jätkamiseks. See on põhimuster keerukate interaktiivsete süsteemide, olekumasinate ja täiustatumate andmetöötluste loomiseks, kus järgmine samm sõltub välisest tagasisidest.

Kahesuunalise suhtluse kasutusjuhtumid

• Korutiinid ja ühistuline multitegumtöötlus: Generaatorid võivad toimida kergekaaluliste korutiinidena, vabatahtlikult kontrolli andes ja andmeid vastu võttes, mis on kasulik keerukate olekute või pikalt kestvate ülesannete haldamiseks ilma peamist lõime blokeerimata (kui seda kombineerida sündmuste silmuste või setTimeout'iga).
• Olekumasinad: Generaatori sisemine olek (kohalikud muutujad, programmkooder) säilitatakse yield kõnede vahel, muutes need ideaalseks olekumasinate modelleerimiseks, kus üleminekud on käivitatud väliste sisendite poolt.
• Sisend/Väljund (I/O) Simulatsioon: Asünkroonsete toimingute või kasutaja sisendi simuleerimiseks pakub next() argumentidega sünkroonset viisi generaatori voo testimiseks ja juhtimiseks.
• Andmetöötluse Pipeliinid Välise Konfiguratsiooniga: Kujutage ette pipeliini, kus teatud töötlemisetapid vajavad parameetreid, mis määratakse täitmise ajal dünaamiliselt.

3. Generaatori objektide meetodid throw() ja return()

Lisaks next()-le pakuvad generaatori objektid ka meetodeid throw() ja return(), mis pakuvad täiendavat juhtimist nende täitmise voo üle väljastpoolt. Need meetodid võimaldavad välisel koodil sisestada väärtusi või sundida varajast lõpetamist, suurendades oluliselt veahaldust ja ressursihaldust keerukates generaatoripõhistes süsteemides.

generatorObject.throw(exception): Vigade sisestamine

generatorObject.throw(exception) kutsumine sisestab erandi generaatorisse selle praeguses peatatud olekus. See erand käitub täpselt nagu throw avaldis generaatori kehas. Kui generaatoril on try...catch plokk yield avaldise ümber, kus see peatati, saab see selle välise vea püüda ja seda töödelda.

Kui generaator viga ei püüa, levib see throw() kutsujale, nagu levib mis tahes tabamata erand.

            function* dataProcessor() {
    try {
        const data = yield "Ootan andmeid...";
        console.log(`Töödeldakse: ${data}`);
        if (typeof data !== 'number') {
            throw new Error("Vigane andmetüüp: oodati numbrit.");
        }
        yield `Andmed töödeldud: ${data * 2}`;
    } catch (error) {
        console.error(`Püütud viga generaatori sees: ${error.message}`);
        return "Viga on töödeldud ja generaator lõpetatud."; // Generaator saab vea korral väärtuse tagastada
    } finally {
        console.log("Generaatori puhastus lõpetatud.");
    }
}

const processor = dataProcessor();

console.log(processor.next().value); // Ootan andmeid...

// Simuleerige välise vea viskamist generaatorisse
console.log("Proovime visata generaatorisse viga...");
let resultWithError = processor.throw(new Error("Väline katkestus!"));
console.log(`Tulemus pärast välist viga: ${resultWithError.value}`); // Viga on töödeldud ja generaator lõpetatud.
console.log(`Lõpetatud pärast viga: ${resultWithError.done}`); // true

console.log("\n--- Teine katse kehtivate andmetega, seejärel sisemise tüübi veaga ---");
const processor2 = dataProcessor();
console.log(processor2.next().value); // Ootan andmeid...
console.log(processor2.next(5).value); // Andmed töödeldud: 10

// Nüüd saatke vigased andmed, mis põhjustab sisemise veaga
let resultInvalidData = processor2.next("abc");
// Generaator püüab oma vea kinni
console.log(`Tulemus pärast vigaseid andmeid: ${resultInvalidData.value}`); // Viga on töödeldud ja generaator lõpetatud.
console.log(`Lõpetatud pärast viga: ${resultInvalidData.done}`); // true

            

              
                Copy
              
            
          

Meetod throw() on hindamatu vea levitamiseks välisest sündmuste silmusest või lubadusketist tagasi generaatorisse, võimaldades ühtset veahaldust generaatorite hallatavate asünkroonsete toimingute kaudu.

generatorObject.return(value): Sundlõpetamine

Meetod generatorObject.return(value) võimaldab teil generaatori enneaegselt lõpetada. Selle kutsumisel generaator lõpetab kohe ja selle next() meetod tagastab seejärel { value: value, done: true } (või { value: undefined, done: true }, kui väärtust ei ole antud). Mis tahes finally plokid generaatoris täidetakse endiselt, tagades nõuetekohase puhastuse.

            function* resourceIntensiveOperation() {
    try {
        let count = 0;
        while (true) {
            yield `Töödeldakse üksust ${++count}`;
            // Simuleerige mõnda rasket tööd
            if (count > 50) { // Ohutuse piirang
                return "Töödeldud palju üksusi, tagastatakse.";
            }
        }
    } finally {
        console.log("Ressursi puhastus intensiivsele toimingule.");
    }
}

const op = resourceIntensiveOperation();

console.log(op.next().value); // Töödeldakse üksust 1
console.log(op.next().value); // Töödeldakse üksust 2
console.log(op.next().value); // Töödeldakse üksust 3

// Otsustati enneaegselt peatada
console.log("Väline otsus: toiming lõpetatakse enneaegselt.");
let finalResult = op.return("Toiming kasutaja poolt tühistatud.");

console.log(`Lõplik tulemus pärast lõpetamist: ${finalResult.value}`); // Toiming kasutaja poolt tühistatud.
console.log(`Lõpetatud: ${finalResult.done}`); // true

// Järgmised kõned näitavad, et see on lõpetatud
console.log(op.next()); // { value: undefined, done: true }

            

              
                Copy
              
            
          

See on ülimalt kasulik stsenaariumite jaoks, kus välised tingimused määravad, et pikalt kestev või ressursimahukas iteratiivne protsess tuleb graafiliselt peatada, näiteks kasutaja tühistamine või teatud piirini jõudmine. finally plokk tagab, et kõik eraldatud ressursid vabastatakse nõuetekohaselt, vältides lekkeid.

Täiustatud mustrid ja globaalsed kasutusjuhtumid

Generaatori protokollilaiendused loovad aluse mõnele kaasaegse JavaScripti kõige võimsamale mustrile, eriti asünkroonsuse ja keerukate andmevoogude haldamisel. Kuigi põhikontseptsioonid jäävad globaalselt samaks, võib nende rakendamine oluliselt lihtsustada arendust erinevates rahvusvahelistes projektides.

Asünkroonne iteratsioon Asünkroonsete generaatorite ja for await...of abil

Iteraatori ja generaatori protokollidele tuginedes tutvustas ECMAScript Asünkroonseid Generaatoreid ja for await...of silmust. Need pakuvad sünkroonse väljanägemisega viisi asünkroonsete andmeallikate itereerimiseks, käsitledes lubaduste või võrgust vastuste vooge nagu oleksid need lihtsad massiivid.

Asünkroonse iteraatori protokoll

Nagu nende sünkroonsete vastete puhul, on asünkroonsetel itereeritavatel objektidel meetod [Symbol.asyncIterator], mis tagastab asünkroonse iteraatori. Asünkroonse iteraatori meetod async next() tagastab lubaduse, mis lahendab objekti { value: ..., done: ... }.

Asünkroonse Generaatori Funktsioonid (async function*)

async function* tagastab automaatselt asünkroonse iteraatori. Kasutate await nende kehas, et peatada täitmine lubaduste jaoks ja yield, et toota väärtusi asünkroonselt.

            async function* fetchPaginatedData(url) {
    let nextPage = url;
    while (nextPage) {
        const response = await fetch(nextPage);
        const data = await response.json();
        yield data.results; // Saada praeguse lehe tulemused

        // Eeldame, et API näitab järgmise lehe URL-i
        nextPage = data.next_page_url; 
        if (nextPage) {
            console.log(`Laaditakse järgmist lehte: ${nextPage}`);
        }
        await new Promise(resolve => setTimeout(resolve, 100)); // Simuleerige võrgukõne viivitust järgmise laadimise jaoks
    }
    return "Kõik lehed laaditud.";
}

// Näide kasutamisest:
async function processAllData() {
    console.log("Alustatakse andmete laadimist...");
    try {
        for await (const pageResults of fetchPaginatedData("https://api.example.com/items?page=1")) {
            console.log("Töödeldud tulemuste leht:", pageResults.length, "üksust.");
            // Kujutage ette iga lehekülje andmete töötlemist siin
            // nt. salvestamine andmebaasi, teisendamine kuvamiseks
            for (const item of pageResults) {
                console.log(`  - Üksuse ID: ${item.id}`);
            }
        }
        console.log("Kõik andmete laadimine ja töötlemine lõpetatud.");
    } catch (error) {
        console.error("Andmete laadimise ajal tekkis viga:", error.message);
    }
}

// Päris rakenduses asendage tõelise URL-i või võltsitud fetch'iga:
// Selle näite jaoks illustreerime ainult struktuuri asendustegijaga:
// (Märkus: `fetch` ja tegelikud URL-id nõuaksid brauseri või Node.js keskkonda)
// await processAllData(); // Kutsuge seda asünkroonses kontekstis

            

              
                Copy
              
            
          

See muster on sügavalt võimas igasuguste asünkroonsete toimingute järjestuste haldamiseks, kus soovite üksusi töödelda ükshaaval, ilma et peaksite ootama kogu voo lõpuleviimist. Mõelge:

• Suurte failide või võrgust voogude tükikaupa lugemine.
• Pagineeritud API-de andmete tõhus töötlemine.
• Reaalajas andmetöötluse pipeliinide loomine.

Globaalselt standardiseerib see lähenemisviis, kuidas arendajad saavad asünkroonseid andmevoogusid tarbida ja toota, edendades järjepidevust erinevates tagasi- ja esiotsa keskkondades.

Generaatorid kui Olekumasinad ja Korutiinid

Generaatorite võime peatuda ja jätkata, koos kahesuunalise suhtlusega, muudab need suurepärasteks tööriistadeks selgete olekumasinate või kergekaaluliste korutiinide loomiseks.

            function* vendingMachine() {
    let balance = 0;
    yield "Tere tulemast! Sisestage münte (väärtused: 1, 2, 5).";

    while (true) {
        const coin = yield `Praegune saldo: ${balance}. Ootan münti või "osta".`;
        if (coin === "buy") {
            if (balance >= 5) { // Eeldades, et üksuse hind on 5
                balance -= 5;
                yield `Siin on teie üksus! Vahetusraha: ${balance}.`;
            } else {
                yield `Ebapiisavad vahendid. Vajate veel ${5 - balance}.`;
            }
        } else if ([1, 2, 5].includes(Number(coin))) {
            balance += Number(coin);
            yield `Sisestatud ${coin}. Uus saldo: ${balance}.`;
        } else {
            yield "Vigane sisend. Palun sisestage 1, 2, 5 või \"osta\".";
        }
    }
}

const machine = vendingMachine();
console.log(machine.next().value); // Tere tulemast! Sisestage münte (väärtused: 1, 2, 5).
console.log(machine.next().value); // Praegune saldo: 0. Ootan münti või "osta".
console.log(machine.next(2).value); // Sisestatud 2. Uus saldo: 2.
console.log(machine.next(5).value); // Sisestatud 5. Uus saldo: 7.
console.log(machine.next("buy").value); // Siin on teie üksus! Vahetusraha: 2.
console.log(machine.next("buy").value); // Praegune saldo: 2. Ootan münti või "osta".
console.log(machine.next("exit").value); // Vigane sisend. Palun sisestage 1, 2, 5 või "osta".

            

              
                Copy
              
            
          

See müügiautomaadi näide illustreerib, kuidas generaator saab säilitada sisemist olekut (balance) ja üleminekuid olekute vahel välise sisendi (coin või "buy") põhjal. See muster on hindamatu mängutsüklite, kasutajajuhendite või mis tahes protsessi jaoks, millel on selgelt määratletud järjestikused sammud ja suhtlused.

Paindlike Andmetöötluse Pipeliinide loomine

Generaatorid, eriti yield*-ga, sobivad suurepäraselt koostatavate andmetöötluse pipeliinide loomiseks. Iga generaator võib esindada töötlemisetappi ja neid saab omavahel ühendada.

            function* filterEvens(numbers) {
    for (const num of numbers) {
        if (num % 2 === 0) {
            yield num;
        }
    }
}

function* doubleValues(numbers) {
    for (const num of numbers) {
        yield num * 2;
    }
}

function* sumUpTo(numbers, limit) {
    let sum = 0;
    for (const num of numbers) {
        if (sum + num > limit) {
            return sum; // Peatab, kui järgmise numbri lisamine ületab piiri
        }
        sum += num;
        yield sum; // Saada kumulatiivne summa
    }
    return sum;
}

// Pipeliini orkestreeriv generaator
function* dataPipeline(data) {
    console.log("Pipeliini etapp 1: Paarisnumbrite filtreerimine...");
    // `yield*` siin itereerib, see ei jäädvusta tagastusväärtust filterEvens'ilt
    // kui filterEvens seda selgesõnaliselt ei tagasta (mis tavaliselt ei tee).
    // Tõeliselt koostatavate pipeliinide jaoks peaks iga etapp tagastama uue generaatori või iteraatori otse.
    
    // Generaatorite otse ühendamine on sageli funktsionaalsem:
    const filteredAndDoubled = doubleValues(filterEvens(data));

    console.log("Pipeliini etapp 2: Summeerimine kuni piirini (100)...");
    const finalSum = yield* sumUpTo(filteredAndDoubled, 100);
    return `Lõplik summa piiri sees: ${finalSum}`;
}

const rawData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
const pipelineExecutor = dataPipeline(rawData);

let pipelineResult = pipelineExecutor.next();
while (!pipelineResult.done) {
    console.log(`Vahepealne pipeliini väljund: ${pipelineResult.value}`);
    pipelineResult = pipelineExecutor.next();
}
console.log(pipelineResult.value);

// Parandatud ühendamise näide illustreerimiseks (otsene funktsionaalne koostamine):
console.log("\n--- Otsese Ühendamise Näide (Funktsionaalne Koostamine) ---");
const processedNumbers = doubleValues(filterEvens(rawData)); // Ühenda itereeritavad objektid
let cumulativeSumIterator = sumUpTo(processedNumbers, 100); // Looge iteraator viimasest etapist

for (const val of cumulativeSumIterator) {
    console.log(`Kumulatiivne Summa: ${val}`);
}
// sumUpTo lõplik tagastusväärtus (kui seda ei tarbinud for...of) pääseks ligi .return() või .next() kaudu pärast done
console.log(`Lõplik kumulatiivne summa (iteraatori tagastusväärtusest): ${cumulativeSumIterator.next().value}`);

// Oodatav väljund näitaks filtreeritud, seejärel kahekordistatud paarisnumbreid, seejärel nende kumulatiivset summat kuni 100.
// Näide järjestus rawData [1,2,3...20] jaoks, mida töötleb filterEvens -> doubleValues -> sumUpTo(..., 100):
// Filtreeritud paarisnumbrid: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
// Kahekordistatud paarisnumbrid: [4, 8, 12, 16, 20, 24, 28, 32, 36, 40]
// Kumulatiivne summa kuni 100:
// Summa: 4
// Summa: 12 (4+8)
// Summa: 24 (12+12)
// Summa: 40 (24+16)
// Summa: 60 (40+20)
// Summa: 84 (60+24)
// Lõplik kumulatiivne summa (iteraatori tagastusväärtusest): 84 (kuna 28 lisamine ületaks 100)

            

              
                Copy
              
            
          

Parandatud ühendamise näide demonstreerib, kuidas funktsionaalset koostamist hõlbustavad loomulikult generaatorid. Iga generaator võtab itereeritava objekti (või teise generaatori) ja toodab uue itereeritava objekti, võimaldades väga paindlikku ja tõhusat andmetöötlust. See lähenemisviis on väga hinnatud keskkondades, mis tegelevad suurte andmehulkade või keerukate analüütiliste töövoogudega, mis on globaalselt tavalised erinevates tööstusharudes.

Generaatorite kasutamise parimad tavad

Generaatorite ja nende protokollilaienduste tõhusaks kasutamiseks kaaluge järgmisi parimaid tavasid:

• Hoidke generaatorid keskendunud: Iga generaator peaks ideaalis täitma ühte, selgelt määratletud ülesannet (nt filtreerimine, kaardistamine, lehe laadimine). See suurendab taaskasutatavust ja testitavust.
• Selged nimesüsteemid: Kasutage generaatorifunktsioonide ja nende yielditud väärtuste jaoks kirjeldavaid nimesid. Näiteks fetchUsersPage() või processCsvRows().
• Töödeldage vigu graafiliselt: Kasutage generaatorites try...catch plokke ja olge valmis kasutama generatorObject.throw() välisest koodist vigade tõhusaks haldamiseks, eriti asünkroonsetes kontekstides.
• Haldage ressursse finally abil: Kui generaator omandab ressursse (nt avab failikäepideme, loob võrguühenduse), kasutage finally plokki, et tagada nende ressursside vabastamine, isegi kui generaator lõpetab enneaegselt return() või tabamata erandi kaudu.
• Eelistage koostamiseks yield*: Mitme itereeritava objekti või generaatori väljundi kombineerimisel on yield* kõige puhtam ja tõhusam delegeerimise viis, muutes teie koodi modulaarseks ja kergemini jälgitavaks.
• Mõistke kahesuunalist suhtlust: Olge argumentidega next() kasutades tahtlik. See on võimas, kuid võib generaatorid raskemini jälgitavaks muuta, kui neid mitte kasutada kaalutletult. Dokumenteerige selgelt, millal sisendeid oodatakse.
• Kaaluge jõudlust: Kuigi generaatorid on tõhusad, eriti laisa hindamise korral, olge teadlik liiga sügavatest yield* delegeerimisahelatest või väga sagedastest next() kutsetest jõudluselt kriitilistes silmustes. Profiilige vajadusel.
• Testige põhjalikult: Testige generaatoreid nagu iga teist funktsiooni. Kontrollige saadud väärtuste järjestust, tagastusväärtust ja seda, kuidas need käituvad, kui neile kutsutakse throw() või return().

Mõju kaasaegsele JavaScripti arengule

Generaatori protokollilaiendused on avaldanud sügavat mõju JavaScripti arengule:

• Asünkroonse koodi lihtsustamine: Enne async/await olid generaatorid koos selliste raamatukogudega nagu co peamine mehhanism asünkroonse koodi kirjutamiseks, mis nägi välja sünkroonsem. Nad sillutasid teed async/await süntaksile, mida täna kasutame ja mis sageli sisemiselt kasutab sarnaseid peatuma ja jätkama täitmise kontseptsioone.
• Täiustatud andmevoogude töötlemine: Generaatorid on suurepärased suurte andmehulkade või lõputute järjestuste laisa töötlemise jaoks. See tähendab, et andmeid töödeldakse nõudmisel, mitte kõike korraga mällu laadides, mis on veebirakenduste, serveripoolse Node.js ja andmeanalüütikatööriistade jõudluse ja skaleeritavuse jaoks ülioluline.
• Funktsionaalsete mustrite edendamine: Pakkudes loomulikku viisi itereeritavate objektide ja iteraatorite loomiseks, võimaldavad generaatorid funktsionaalsemaid programmeerimisparadigmaid, mis võimaldavad elegantset andmetöötluse koostamist.
• Vastupidavate juhtimisvoogude loomine: Nende võime peatuda, jätkata, sisendit vastu võtta ja vigu töödelda muudab need mitmekülgseks tööriistaks keerukate juhtimisvoogude, olekumasinate ja sündmuspõhiste arhitektuuride rakendamiseks.

Üha enam ühendatud globaalses arendusmaastikus, kus erinevad meeskonnad teevad koostööd projektidega alates reaalajas andmeanalüütika platvormidest kuni interaktiivsete veebikogemusteni, pakuvad generaatorid ühist, võimsat keelefunktsiooni keerukate probleemide lahendamiseks selguse ja tõhususega. Nende universaalne rakendatavus muudab need väärtuslikuks oskuseks igale JavaScripti arendajale kogu maailmas.

Kokkuvõte: Iteratsiooni täieliku potentsiaali avamine

JavaScripti generaatorid, koos nende laiendatud protokolliga, esindavad märkimisväärset edasiminekut selles, kuidas me haldame iteratsiooni, asünkroonseid toiminguid ja keerukaid juhtimisvoogusid. Alates yield* pakutavast elegantsest delegeerimisest kuni next() argumentide kaudu pakutava võimsa kahesuunalise suhtluseni ning throw() ja return() abil robustse vea-/lõpetamise haldamiseni pakuvad need funktsioonid arendajatele enneolematut kontrolli ja paindlikkust.

Mõistes ja valitsedes neid täiustatud iteraatoriliideseid, ei õpi te lihtsalt uut süntaksit; te omandate tööriistu, et kirjutada tõhusamat, loetavamat ja paremini hooldatavat koodi. Olenemata sellest, kas loote keerukaid andmepipeliine, rakendate keerukaid olekumasinaid või lihtsustate asünkroonseid toiminguid, pakuvad generaatorid võimsat ja idioomilist lahendust.

Võtke omaks täiustatud iteraatoriliides. Uurige selle võimalusi. Teie JavaScripti kood – ja teie projektid – muutuvad sellest ainult paremaks.