KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

TransformStream: transform, flush en controller.enqueue

Verwerk invoerblokken met `transform()`, geef resultaten door met `controller.enqueue()` en geef bij normaal sluiten de buffer vrij met `flush()`.

Versie: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

new TransformStream()
new TransformStream(transformer)
new TransformStream(transformer, writableStrategy)
new TransformStream(transformer, writableStrategy, readableStrategy)

// Optional transformer methods:
transform(chunk, controller)
flush(controller)

// Output from either method:
controller.enqueue(chunk)

Een TransformStream verbindt een invoerkant (writable) met een uitvoerkant (readable). De constructor accepteert een optioneel transformer-object. De volgende twee optionele argumenten bepalen de wachtrijstrategieën voor de schrijf- en leeskant, in die volgorde. Dit is onderdeel van de Web Streams API, niet van ECMAScript 2024. Controleer of je doelomgeving de API ondersteunt.

transform(chunk, controller) wordt aangeroepen voor elk invoerblok zodra het kan worden verwerkt. Roep controller.enqueue(chunk) op de meegegeven TransformStreamDefaultController zo vaak aan als nodig om nul, één of meerdere uitvoerblokken door te geven. De retourwaarde van de callback is geen uitvoer. Zonder transform() worden de blokken ongewijzigd doorgegeven.

De optionele callback flush(controller) draait bij het normaal sluiten van de schrijfkant, nadat alle invoerblokken met succes zijn verwerkt. Deze callback kan resterende gegevens uit de buffer doorgeven voordat de API de leeskant sluit. Het is geen opruimfunctie bij annuleren of afbreken. De API wacht op een promise die een van beide callbacks teruggeeft. Een exception of afgewezen promise zet de stream in een fouttoestand. Neem asynchroon werk dus op in de promise die je teruggeeft.

enqueue() geeft een blok door aan de leeskant, retourneert undefined en gooit een TypeError als die kant geen blokken meer accepteert. De aanroep wacht niet op een afnemer. Tegendruk (backpressure) kan de verwerking van latere schrijfacties vertragen, maar stelt geen harde bovengrens aan het aantal enqueue()-aanroepen binnen één callback. Sluit een afnemer aan voordat je op voltooiing van de schrijfacties wacht.

Voorbeelden

(async () => {
  const input = new ReadableStream({
    start(sourceController) {
      for (const value of [1, 2, 3]) sourceController.enqueue(value);
      sourceController.close();
    },
  });

  let pending = [];
  const pairs = new TransformStream({
    transform(chunk, controller) {
      pending.push(chunk);
      if (pending.length === 2) {
        controller.enqueue(pending);
        pending = [];
      }
    },
    flush(controller) {
      if (pending.length > 0) controller.enqueue(pending);
    },
  });

  const output = [];
  await input.pipeThrough(pairs).pipeTo(new WritableStream({
    write(chunk) {
      output.push(chunk);
    },
  }));
  console.log(JSON.stringify(output));
})().catch((error) => console.error(error));

Resultaat

[[1,2],[3]]

Standaard geeft `pipeThrough()` het normale sluiten van de bron door aan de schrijfkant van de transformatie, terwijl `pipeTo()` de uitvoer leest zodra die beschikbaar komt. `transform()` geeft het paar `[1,2]` door en `flush()` het overgebleven element als `[3]`.

Gerelateerde lessen

  • JavaScript · Les 4 · Gevorderd · Versie: 4

Bronnen