Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

TransformStream: transform, flush e controller.enqueue

Elabora i blocchi in ingresso con `transform()`, emetti i risultati con `controller.enqueue()` e svuota il buffer con `flush()` alla chiusura normale.

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

Sintassi

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)

TransformStream collega un lato di ingresso (writable) a un lato di uscita (readable). Il costruttore accetta un oggetto transformer facoltativo. I due argomenti facoltativi successivi definiscono le strategie di accodamento, prima per la scrittura, poi per la lettura. Fa parte dell’API Web Streams, non di ECMAScript 2024: verifica il supporto nell’ambiente di esecuzione di destinazione.

transform(chunk, controller) viene chiamata per ogni blocco in ingresso quando è pronto per essere elaborato. Per emettere zero, uno o più blocchi di uscita, chiama controller.enqueue(chunk) il numero corrispondente di volte sul TransformStreamDefaultController ricevuto. Il valore restituito dalla callback non è un dato di uscita. Senza transform(), i blocchi passano invariati.

La callback facoltativa flush(controller) viene chiamata alla chiusura normale del lato di scrittura, dopo che tutti i blocchi in ingresso sono stati elaborati con successo. Può emettere i dati rimasti nel buffer prima che l’API chiuda il lato di lettura; non è una callback di pulizia in caso di annullamento o interruzione. L’API attende la promessa restituita da una delle due callback. Un’eccezione o una promessa rifiutata porta il flusso in uno stato di errore: includi quindi il lavoro asincrono nella promessa che restituisci.

enqueue() consegna un blocco al lato di lettura, restituisce undefined e lancia TypeError se quel lato non accetta più blocchi. Non aspetta il consumatore. La contropressione può ritardare l’elaborazione delle scritture successive, ma non impone un limite rigido al numero di chiamate a enqueue() nella stessa callback. Collega un consumatore prima di attendere il completamento delle scritture.

Esempi

(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));

Risultato

[[1,2],[3]]

Per impostazione predefinita, `pipeThrough()` propaga la chiusura normale della sorgente al lato di scrittura della trasformazione, mentre `pipeTo()` consuma l’uscita man mano che arriva. `transform()` emette la coppia `[1,2]` e `flush()` emette l’elemento rimasto come `[3]`.

Lezioni correlate

  • JavaScript · Lezione 4 · Avanzato · Versione: 4

Fonti