Node.js v26.0.0 Dokumentation

Web Streams API#

Eine Implementierung des WHATWG Streams Standard.

Übersicht#

Der WHATWG Streams Standard (oder „Web Streams“) definiert eine API für die Handhabung von Streaming-Daten. Sie ähnelt der Node.js Streams-API, kam jedoch später auf und hat sich als „Standard“-API für Streaming-Daten in vielen JavaScript-Umgebungen etabliert.

Es gibt drei Haupttypen von Objekten

• ReadableStream – Repräsentiert eine Quelle für Streaming-Daten.
• WritableStream – Repräsentiert ein Ziel für Streaming-Daten.
• TransformStream – Repräsentiert einen Algorithmus zum Transformieren von Streaming-Daten.

Beispiel ReadableStream#

Dieses Beispiel erstellt einen einfachen ReadableStream, der kontinuierlich einmal pro Sekunde den aktuellen performance.now()-Zeitstempel ausgibt. Ein asynchrones Iterable wird verwendet, um die Daten aus dem Stream zu lesen.

import {
  ReadableStream,
} from 'node:stream/web';

import {
  setInterval as every,
} from 'node:timers/promises';

import {
  performance,
} from 'node:perf_hooks';

const SECOND = 1000;

const stream = new ReadableStream({
  async start(controller) {
    for await (const _ of every(SECOND))
      controller.enqueue(performance.now());
  },
});

for await (const value of stream)
  console.log(value);
const {
  ReadableStream,
} = require('node:stream/web');

const {
  setInterval: every,
} = require('node:timers/promises');

const {
  performance,
} = require('node:perf_hooks');

const SECOND = 1000;

const stream = new ReadableStream({
  async start(controller) {
    for await (const _ of every(SECOND))
      controller.enqueue(performance.now());
  },
});

(async () => {
  for await (const value of stream)
    console.log(value);
})();
copy

Interoperabilität von Node.js-Streams#

Node.js-Streams können über die Methoden toWeb und fromWeb, die für stream.Readable-, stream.Writable- und stream.Duplex-Objekte verfügbar sind, in Web-Streams umgewandelt werden und umgekehrt.

Weitere Details finden Sie in der entsprechenden Dokumentation

• stream.Readable.toWeb
• stream.Readable.fromWeb
• stream.Writable.toWeb
• stream.Writable.fromWeb
• stream.Duplex.toWeb
• stream.Duplex.fromWeb

API#

Klasse: ReadableStream#

new ReadableStream([underlyingSource [, strategy]])#

• underlyingSource <Object>
  • start <Function> Eine benutzerdefinierte Funktion, die sofort nach der Erstellung des ReadableStream aufgerufen wird.
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • Gibt zurück: undefined oder ein mit undefined aufgelöstes Promise.
  • pull <Function> Eine benutzerdefinierte Funktion, die wiederholt aufgerufen wird, wenn die interne Warteschlange des ReadableStream nicht voll ist. Der Vorgang kann synchron oder asynchron sein. Falls asynchron, wird die Funktion erst erneut aufgerufen, wenn das zuvor zurückgegebene Promise aufgelöst wurde.
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • Gibt zurück: Ein mit undefined aufgelöstes Promise.
  • cancel <Function> Eine benutzerdefinierte Funktion, die aufgerufen wird, wenn der ReadableStream abgebrochen wird.
    • reason <any>
    • Gibt zurück: Ein mit undefined aufgelöstes Promise.
  • type <string> Muss 'bytes' oder undefined sein.
  • autoAllocateChunkSize <number> Wird nur verwendet, wenn type gleich 'bytes' ist. Bei einem Wert ungleich null wird automatisch ein View-Buffer für ReadableByteStreamController.byobRequest zugewiesen. Wenn nicht gesetzt, müssen die internen Warteschlangen des Streams verwendet werden, um Daten über den Standard-Reader ReadableStreamDefaultReader zu übertragen.
• strategy <Object>
  • highWaterMark <number> Die maximale Größe der internen Warteschlange, bevor Backpressure angewendet wird.
  • size <Function> Eine benutzerdefinierte Funktion zur Bestimmung der Größe jedes Datenblocks.
    • chunk <any>
    • Gibt zurück: <number>

readableStream.locked#

• Typ: <boolean> Auf true gesetzt, wenn ein aktiver Reader für diesen <ReadableStream> existiert.

Die Eigenschaft readableStream.locked ist standardmäßig false und wechselt zu true, solange ein aktiver Reader die Daten des Streams konsumiert.

readableStream.cancel([reason])#

• reason <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise, sobald der Abbruch abgeschlossen ist.

readableStream.getReader([options])#

• options <Object>
  • mode <string> 'byob' oder undefined
• Gibt zurück: <ReadableStreamDefaultReader> | <ReadableStreamBYOBReader>

import { ReadableStream } from 'node:stream/web';

const stream = new ReadableStream();

const reader = stream.getReader();

console.log(await reader.read());
const { ReadableStream } = require('node:stream/web');

const stream = new ReadableStream();

const reader = stream.getReader();

reader.read().then(console.log);
copy

Setzt readableStream.locked auf true.

readableStream.pipeThrough(transform[, options])#

• transform <Object>
  • readable <ReadableStream> Der ReadableStream, an den transform.writable die potenziell modifizierten Daten sendet, die es von diesem ReadableStream empfängt.
  • writable <WritableStream> Der WritableStream, in den die Daten dieses ReadableStream geschrieben werden.
• options <Object>
  • preventAbort <boolean> Wenn true, führen Fehler in diesem ReadableStream nicht zum Abort von transform.writable.
  • preventCancel <boolean> Wenn true, führen Fehler im Ziel-transform.writable nicht zum Abbruch dieses ReadableStream.
  • preventClose <boolean> Wenn true, führt das Schließen dieses ReadableStream nicht zum Schließen von transform.writable.
  • signal <AbortSignal> Ermöglicht den Abbruch der Datenübertragung mittels eines <AbortController>.
• Gibt zurück: <ReadableStream> Von transform.readable.

Verbindet diesen <ReadableStream> mit dem Paar aus <ReadableStream> und <WritableStream>, die im Argument transform bereitgestellt werden, sodass Daten aus diesem <ReadableStream> in transform.writable geschrieben, ggf. transformiert und dann an transform.readable weitergeleitet werden. Sobald die Pipeline konfiguriert ist, wird transform.readable zurückgegeben.

Setzt readableStream.locked auf true, während der Pipe-Vorgang aktiv ist.

import {
  ReadableStream,
  TransformStream,
} from 'node:stream/web';

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue('a');
  },
});

const transform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const transformedStream = stream.pipeThrough(transform);

for await (const chunk of transformedStream)
  console.log(chunk);
  // Prints: A
const {
  ReadableStream,
  TransformStream,
} = require('node:stream/web');

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue('a');
  },
});

const transform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const transformedStream = stream.pipeThrough(transform);

(async () => {
  for await (const chunk of transformedStream)
    console.log(chunk);
    // Prints: A
})();
copy

readableStream.pipeTo(destination[, options])#

• destination <WritableStream> Ein <WritableStream>, in den die Daten dieses ReadableStream geschrieben werden.
• options <Object>
  • preventAbort <boolean> Wenn true, führen Fehler in diesem ReadableStream nicht zum Abort von destination.
  • preventCancel <boolean> Wenn true, führen Fehler in destination nicht zum Abbruch dieses ReadableStream.
  • preventClose <boolean> Wenn true, führt das Schließen dieses ReadableStream nicht zum Schließen von destination.
  • signal <AbortSignal> Ermöglicht den Abbruch der Datenübertragung mittels eines <AbortController>.
• Gibt zurück: Ein mit undefined aufgelöstes Promise

Setzt readableStream.locked auf true, während der Pipe-Vorgang aktiv ist.

readableStream.tee()#

• Gibt zurück: <ReadableStream[]>

Gibt ein Paar neuer <ReadableStream>-Instanzen zurück, an die die Daten dieses ReadableStream weitergeleitet werden. Beide erhalten dieselben Daten.

Setzt readableStream.locked auf true.

readableStream.values([options])#

• options <Object>
  • preventCancel <boolean> Wenn true, wird verhindert, dass der <ReadableStream> geschlossen wird, wenn der asynchrone Iterator abrupt endet. Standard: false.

Erstellt und gibt einen asynchronen Iterator zurück, der zum Konsumieren der Daten dieses ReadableStream verwendet werden kann.

Setzt readableStream.locked auf true, während der asynchrone Iterator aktiv ist.

import { Buffer } from 'node:buffer';

const stream = new ReadableStream(getSomeSource());

for await (const chunk of stream.values({ preventCancel: true }))
  console.log(Buffer.from(chunk).toString());
copy

Async-Iteration#

Das <ReadableStream>-Objekt unterstützt das Async-Iterator-Protokoll mittels for await-Syntax.

import { Buffer } from 'node:buffer';

const stream = new ReadableStream(getSomeSource());

for await (const chunk of stream)
  console.log(Buffer.from(chunk).toString());
copy

Der asynchrone Iterator konsumiert den <ReadableStream>, bis er endet.

Wenn der asynchrone Iterator vorzeitig beendet wird (durch break, return oder throw), wird der <ReadableStream> standardmäßig geschlossen. Um das automatische Schließen des <ReadableStream> zu verhindern, verwenden Sie die Methode readableStream.values(), um den asynchronen Iterator abzurufen, und setzen Sie die Option preventCancel auf true.

Der <ReadableStream> darf nicht gesperrt sein (d. h. es darf kein existierender aktiver Reader vorhanden sein). Während der asynchronen Iteration ist der <ReadableStream> gesperrt.

Übertragung mit postMessage()#

Eine <ReadableStream>-Instanz kann mithilfe eines <MessagePort> übertragen werden.

const stream = new ReadableStream(getReadableSourceSomehow());

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  data.getReader().read().then((chunk) => {
    console.log(chunk);
  });
};

port2.postMessage(stream, [stream]);
copy

ReadableStream.from(iterable)#

• iterable <Iterable> Ein Objekt, das das Iterable-Protokoll Symbol.asyncIterator oder Symbol.iterator implementiert.

Eine Hilfsmethode, die einen neuen <ReadableStream> aus einem Iterable erstellt.

import { ReadableStream } from 'node:stream/web';

async function* asyncIterableGenerator() {
  yield 'a';
  yield 'b';
  yield 'c';
}

const stream = ReadableStream.from(asyncIterableGenerator());

for await (const chunk of stream)
  console.log(chunk); // Prints: 'a', 'b', 'c'
const { ReadableStream } = require('node:stream/web');

async function* asyncIterableGenerator() {
  yield 'a';
  yield 'b';
  yield 'c';
}

(async () => {
  const stream = ReadableStream.from(asyncIterableGenerator());

  for await (const chunk of stream)
    console.log(chunk); // Prints: 'a', 'b', 'c'
})();
copy

Um den resultierenden <ReadableStream> in einen <WritableStream> zu pipen, sollte das <Iterable> eine Sequenz von <Buffer>-, <TypedArray>- oder <DataView>-Objekten liefern.

import { ReadableStream } from 'node:stream/web';
import { Buffer } from 'node:buffer';

async function* asyncIterableGenerator() {
  yield Buffer.from('a');
  yield Buffer.from('b');
  yield Buffer.from('c');
}

const stream = ReadableStream.from(asyncIterableGenerator());

await stream.pipeTo(createWritableStreamSomehow());
const { ReadableStream } = require('node:stream/web');
const { Buffer } = require('node:buffer');

async function* asyncIterableGenerator() {
  yield Buffer.from('a');
  yield Buffer.from('b');
  yield Buffer.from('c');
}

const stream = ReadableStream.from(asyncIterableGenerator());

(async () => {
  await stream.pipeTo(createWritableStreamSomehow());
})();
copy

Klasse: ReadableStreamDefaultReader#

Standardmäßig gibt der Aufruf von readableStream.getReader() ohne Argumente eine Instanz von ReadableStreamDefaultReader zurück. Der Standard-Reader behandelt die durch den Stream geleiteten Datenblöcke als undurchsichtige Werte, was es dem <ReadableStream> ermöglicht, mit nahezu jedem JavaScript-Wert zu arbeiten.

new ReadableStreamDefaultReader(stream)#

• stream <ReadableStream>

Erstellt einen neuen <ReadableStreamDefaultReader>, der an den angegebenen <ReadableStream> gebunden ist.

readableStreamDefaultReader.cancel([reason])#

• reason <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Bricht den <ReadableStream> ab und gibt ein Promise zurück, das aufgelöst wird, wenn der zugrunde liegende Stream abgebrochen wurde.

readableStreamDefaultReader.closed#

• Typ: <Promise> Wird mit undefined aufgelöst, wenn der zugehörige <ReadableStream> geschlossen wird, oder abgelehnt, wenn ein Fehler auftritt oder die Sperre des Readers freigegeben wird, bevor der Stream vollständig geschlossen ist.

readableStreamDefaultReader.read()#

• Gibt zurück: Ein Promise, das mit einem Objekt aufgelöst wird
  • value <any>
  • done <boolean>

Fordert den nächsten Datenblock vom zugrunde liegenden <ReadableStream> an und gibt ein Promise zurück, das mit den Daten aufgelöst wird, sobald diese verfügbar sind.

readableStreamDefaultReader.releaseLock()#

Gibt die Sperre dieses Readers auf dem zugrunde liegenden <ReadableStream> frei.

Klasse: ReadableStreamBYOBReader#

Der ReadableStreamBYOBReader ist ein alternativer Konsument für byteorientierte <ReadableStream>s (solche, die bei der Erstellung des ReadableStream mit underlyingSource.type auf 'bytes' gesetzt wurden).

BYOB steht für „bring your own buffer“. Dies ist ein Muster, das ein effizienteres Lesen von byteorientierten Daten ermöglicht und überflüssige Kopiervorgänge vermeidet.

import {
  open,
} from 'node:fs/promises';

import {
  ReadableStream,
} from 'node:stream/web';

import { Buffer } from 'node:buffer';

class Source {
  type = 'bytes';
  autoAllocateChunkSize = 1024;

  async start(controller) {
    this.file = await open(new URL(import.meta.url));
    this.controller = controller;
  }

  async pull(controller) {
    const view = controller.byobRequest?.view;
    const {
      bytesRead,
    } = await this.file.read({
      buffer: view,
      offset: view.byteOffset,
      length: view.byteLength,
    });

    if (bytesRead === 0) {
      await this.file.close();
      this.controller.close();
    }
    controller.byobRequest.respond(bytesRead);
  }
}

const stream = new ReadableStream(new Source());

async function read(stream) {
  const reader = stream.getReader({ mode: 'byob' });

  const chunks = [];
  let result;
  do {
    result = await reader.read(Buffer.alloc(100));
    if (result.value !== undefined)
      chunks.push(Buffer.from(result.value));
  } while (!result.done);

  return Buffer.concat(chunks);
}

const data = await read(stream);
console.log(Buffer.from(data).toString());
copy

new ReadableStreamBYOBReader(stream)#

• stream <ReadableStream>

Erstellt einen neuen ReadableStreamBYOBReader, der an den angegebenen <ReadableStream> gebunden ist.

readableStreamBYOBReader.cancel([reason])#

• reason <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Bricht den <ReadableStream> ab und gibt ein Promise zurück, das aufgelöst wird, wenn der zugrunde liegende Stream abgebrochen wurde.

readableStreamBYOBReader.closed#

• Typ: <Promise> Wird mit undefined aufgelöst, wenn der zugehörige <ReadableStream> geschlossen wird, oder abgelehnt, wenn ein Fehler auftritt oder die Sperre des Readers freigegeben wird, bevor der Stream vollständig geschlossen ist.

readableStreamBYOBReader.read(view[, options])#

• view <Buffer> | <TypedArray> | <DataView>
• options <Object>
  • min <number> Wenn gesetzt, wird das zurückgegebene Promise erst aufgelöst, sobald mindestens min Elemente verfügbar sind. Wenn nicht gesetzt, wird das Promise aufgelöst, sobald mindestens ein Element verfügbar ist.
• Gibt zurück: Ein Promise, das mit einem Objekt aufgelöst wird
  • value <TypedArray> | <DataView>
  • done <boolean>

Fordert den nächsten Datenblock vom zugrunde liegenden <ReadableStream> an und gibt ein Promise zurück, das mit den Daten aufgelöst wird, sobald diese verfügbar sind.

Übergeben Sie kein gepooltes <Buffer>-Objekt an diese Methode. Gepoolte Buffer-Objekte werden mit Buffer.allocUnsafe() oder Buffer.from() erstellt oder von verschiedenen Callbacks des node:fs-Moduls zurückgegeben. Diese Arten von Buffers verwenden ein zugrunde liegendes <ArrayBuffer>, das alle Daten aller gepoolten Buffer-Instanzen enthält. Wenn ein Buffer, ein <TypedArray> oder ein <DataView> an readableStreamBYOBReader.read() übergeben wird, wird der zugrunde liegende ArrayBuffer der View getrennt, wodurch alle bestehenden Views auf diesem ArrayBuffer ungültig werden. Dies kann katastrophale Folgen für Ihre Anwendung haben.

readableStreamBYOBReader.releaseLock()#

Gibt die Sperre dieses Readers auf dem zugrunde liegenden <ReadableStream> frei.

Klasse: ReadableStreamDefaultController#

Jeder <ReadableStream> besitzt einen Controller, der für den internen Zustand und die Verwaltung der Warteschlange des Streams verantwortlich ist. Der ReadableStreamDefaultController ist die Standard-Controller-Implementierung für ReadableStreams, die nicht byteorientiert sind.

readableStreamDefaultController.close()#

Schließt den <ReadableStream>, mit dem dieser Controller verknüpft ist.

readableStreamDefaultController.desiredSize#

• Typ: <number>

Gibt die Menge der Daten zurück, die noch benötigt werden, um die Warteschlange des <ReadableStream> zu füllen.

readableStreamDefaultController.enqueue([chunk])#

• chunk <any>

Fügt der Warteschlange des <ReadableStream> einen neuen Datenblock hinzu.

readableStreamDefaultController.error([error])#

• error <any>

Signalisiert einen Fehler, der dazu führt, dass der <ReadableStream> einen Fehler meldet und geschlossen wird.

Klasse: ReadableByteStreamController#

Jeder <ReadableStream> besitzt einen Controller, der für den internen Zustand und die Verwaltung der Warteschlange des Streams verantwortlich ist. Der ReadableByteStreamController ist für byteorientierte ReadableStreams vorgesehen.

readableByteStreamController.byobRequest#

• Typ: <ReadableStreamBYOBRequest>

readableByteStreamController.close()#

Schließt den <ReadableStream>, mit dem dieser Controller verknüpft ist.

readableByteStreamController.desiredSize#

• Typ: <number>

Gibt die Menge der Daten zurück, die noch benötigt werden, um die Warteschlange des <ReadableStream> zu füllen.

readableByteStreamController.enqueue(chunk)#

• chunk <Buffer> | <TypedArray> | <DataView>

Fügt der Warteschlange des <ReadableStream> einen neuen Datenblock hinzu.

readableByteStreamController.error([error])#

• error <any>

Signalisiert einen Fehler, der dazu führt, dass der <ReadableStream> einen Fehler meldet und geschlossen wird.

Klasse: ReadableStreamBYOBRequest#

Bei der Verwendung von ReadableByteStreamController in byteorientierten Streams und ReadableStreamBYOBReader bietet die Eigenschaft readableByteStreamController.byobRequest Zugriff auf eine ReadableStreamBYOBRequest-Instanz, die die aktuelle Leseanforderung darstellt. Das Objekt wird verwendet, um Zugriff auf den ArrayBuffer/TypedArray zu erhalten, der für die Leseanforderung zum Füllen bereitgestellt wurde, und bietet Methoden, um zu signalisieren, dass die Daten bereitgestellt wurden.

readableStreamBYOBRequest.respond(bytesWritten)#

• bytesWritten <number>

Signalisiert, dass die Anzahl der Bytes bytesWritten in readableStreamBYOBRequest.view geschrieben wurde.

readableStreamBYOBRequest.respondWithNewView(view)#

• view <Buffer> | <TypedArray> | <DataView>

Signalisiert, dass die Anforderung mit Bytes erfüllt wurde, die in einen neuen Buffer, TypedArray oder DataView geschrieben wurden.

readableStreamBYOBRequest.view#

• Typ: <Buffer> | <TypedArray> | <DataView>

Klasse: WritableStream#

Der WritableStream ist ein Ziel, an das Stream-Daten gesendet werden.

import {
  WritableStream,
} from 'node:stream/web';

const stream = new WritableStream({
  write(chunk) {
    console.log(chunk);
  },
});

await stream.getWriter().write('Hello World');
copy

new WritableStream([underlyingSink[, strategy]])#

• underlyingSink <Object>
  • start <Function> Eine benutzerdefinierte Funktion, die sofort nach der Erstellung des WritableStream aufgerufen wird.
  • controller <WritableStreamDefaultController>
  • Gibt zurück: undefined oder ein mit undefined aufgelöstes Promise.
• write <Function> Eine benutzerdefinierte Funktion, die aufgerufen wird, wenn ein Datenblock in den WritableStream geschrieben wurde.
• chunk <any>
• controller <WritableStreamDefaultController>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

writableStream.abort([reason])#

• reason <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Beendet den WritableStream abrupt. Alle in der Warteschlange befindlichen Schreibvorgänge werden abgebrochen, und die zugehörigen Promises werden abgelehnt.

writableStream.close()#

• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Schließt den WritableStream, wenn keine weiteren Schreibvorgänge erwartet werden.

writableStream.getWriter()#

• Gibt zurück: <WritableStreamDefaultWriter>

Erstellt und gibt eine neue Writer-Instanz zurück, die zum Schreiben von Daten in den WritableStream verwendet werden kann.

writableStream.locked#

• Typ: <boolean>

Die Eigenschaft writableStream.locked ist standardmäßig false und wechselt zu true, solange ein aktiver Writer an diesen WritableStream gebunden ist.

Übertragung mit postMessage()#

Eine <WritableStream>-Instanz kann mithilfe eines <MessagePort> übertragen werden.

const stream = new WritableStream(getWritableSinkSomehow());

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  data.getWriter().write('hello');
};

port2.postMessage(stream, [stream]);
copy

Klasse: WritableStreamDefaultWriter#

new WritableStreamDefaultWriter(stream)#

• stream <WritableStream>

Erstellt einen neuen WritableStreamDefaultWriter, der an den angegebenen WritableStream gebunden ist.

writableStreamDefaultWriter.abort([reason])#

• reason <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Beendet den WritableStream abrupt. Alle in der Warteschlange befindlichen Schreibvorgänge werden abgebrochen, und die zugehörigen Promises werden abgelehnt.

writableStreamDefaultWriter.close()#

• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Schließt den WritableStream, wenn keine weiteren Schreibvorgänge erwartet werden.

writableStreamDefaultWriter.closed#

• Typ: <Promise> Wird mit undefined aufgelöst, wenn der zugehörige <WritableStream> geschlossen wird, oder abgelehnt, wenn ein Fehler auftritt oder die Sperre des Writers freigegeben wird, bevor der Stream vollständig geschlossen ist.

writableStreamDefaultWriter.desiredSize#

• Typ: <number>

Die Datenmenge, die erforderlich ist, um die Warteschlange des <WritableStream> zu füllen.

writableStreamDefaultWriter.ready#

• Typ: <Promise> Wird mit undefined aufgelöst, wenn der Writer einsatzbereit ist.

writableStreamDefaultWriter.releaseLock()#

Gibt die Sperre dieses Writers auf dem zugrunde liegenden <ReadableStream> frei.

writableStreamDefaultWriter.write([chunk])#

• chunk <any>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

Fügt der Warteschlange des <WritableStream> einen neuen Datenblock hinzu.

Klasse: WritableStreamDefaultController#

Der WritableStreamDefaultController verwaltet den internen Zustand des <WritableStream>.

writableStreamDefaultController.error([error])#

• error <any>

Wird vom Benutzercode aufgerufen, um zu signalisieren, dass während der Verarbeitung der WritableStream-Daten ein Fehler aufgetreten ist. Wenn dies aufgerufen wird, wird der <WritableStream> abgebrochen und aktuell ausstehende Schreibvorgänge werden abgebrochen.

writableStreamDefaultController.signal#

• Typ: <AbortSignal> Ein AbortSignal, das verwendet werden kann, um ausstehende Schreib- oder Schließvorgänge abzubrechen, wenn ein <WritableStream> abgebrochen wird.

Klasse: TransformStream#

Ein TransformStream besteht aus einem <ReadableStream> und einem <WritableStream>, die so miteinander verbunden sind, dass die in den WritableStream geschriebenen Daten empfangen und potenziell transformiert werden, bevor sie in die Warteschlange des ReadableStream gelangen.

import {
  TransformStream,
} from 'node:stream/web';

const transform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

await Promise.all([
  transform.writable.getWriter().write('A'),
  transform.readable.getReader().read(),
]);
copy

new TransformStream([transformer[, writableStrategy[, readableStrategy]]])#

• transformer <Object>
  • start <Function> Eine benutzerdefinierte Funktion, die sofort nach der Erstellung des TransformStream aufgerufen wird.
  • controller <TransformStreamDefaultController>
  • Gibt zurück: undefined oder ein mit undefined aufgelöstes Promise
• transform <Function> Eine benutzerdefinierte Funktion, die einen in transformStream.writable geschriebenen Datenblock empfängt und potenziell modifiziert, bevor sie ihn an transformStream.readable weiterleitet.
• chunk <any>
• controller <TransformStreamDefaultController>
• Gibt zurück: Ein mit undefined aufgelöstes Promise.

transformStream.readable#

• Typ: <ReadableStream>

transformStream.writable#

• Typ: <WritableStream>

Übertragung mit postMessage()#

Eine <TransformStream>-Instanz kann mithilfe eines <MessagePort> übertragen werden.

const stream = new TransformStream();

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  const { writable, readable } = data;
  // ...
};

port2.postMessage(stream, [stream]);
copy

Klasse: TransformStreamDefaultController#

Der TransformStreamDefaultController verwaltet den internen Zustand des TransformStream.

transformStreamDefaultController.desiredSize#

• Typ: <number>

Die Datenmenge, die erforderlich ist, um die Warteschlange der lesbaren Seite zu füllen.

transformStreamDefaultController.enqueue([chunk])#

• chunk <any>

Fügt der Warteschlange der lesbaren Seite einen Datenblock hinzu.

transformStreamDefaultController.error([reason])#

• reason <any>

Signalisiert sowohl der lesbaren als auch der beschreibbaren Seite, dass während der Verarbeitung der Transform-Daten ein Fehler aufgetreten ist, was dazu führt, dass beide Seiten abrupt geschlossen werden.

transformStreamDefaultController.terminate()#

Schließt die lesbare Seite des Transports und führt dazu, dass die beschreibbare Seite abrupt mit einem Fehler geschlossen wird.

Klasse: ByteLengthQueuingStrategy#

new ByteLengthQueuingStrategy(init)#

• init <Object>
• highWaterMark <number>

byteLengthQueuingStrategy.highWaterMark#

• Typ: <number>

byteLengthQueuingStrategy.size#

• Typ: <Function>
  • chunk <any>
  • Gibt zurück: <number>

Klasse: CountQueuingStrategy#

new CountQueuingStrategy(init)#

• init <Object>
• highWaterMark <number>

countQueuingStrategy.highWaterMark#

• Typ: <number>

countQueuingStrategy.size#

• Typ: <Function>
  • chunk <any>
  • Gibt zurück: <number>

Klasse: TextEncoderStream#

new TextEncoderStream()#

Erstellt eine neue TextEncoderStream-Instanz.

textEncoderStream.encoding#

• Typ: <string>

Die vom TextEncoderStream-Instanz unterstützte Kodierung.

textEncoderStream.readable#

• Typ: <ReadableStream>

textEncoderStream.writable#

• Typ: <WritableStream>

Klasse: TextDecoderStream#

new TextDecoderStream([encoding[, options]])#

• encoding <string> Identifiziert die encoding, die diese TextDecoder-Instanz unterstützt. Standard: 'utf-8'.
• options <Object>
  • fatal <boolean> true, wenn Dekodierungsfehler fatal sind.
  • ignoreBOM <boolean> Wenn true, schließt TextDecoderStream die Byte-Order-Markierung (BOM) in das dekodierte Ergebnis ein. Wenn false, wird die BOM aus der Ausgabe entfernt. Diese Option wird nur verwendet, wenn encoding auf 'utf-8', 'utf-16be' oder 'utf-16le' gesetzt ist. Standard: false.

Erstellt eine neue TextDecoderStream-Instanz.

textDecoderStream.encoding#

• Typ: <string>

Die vom TextDecoderStream-Instanz unterstützte Kodierung.

textDecoderStream.fatal#

• Typ: <boolean>

Der Wert ist true, wenn Dekodierungsfehler zu einem TypeError führen.

textDecoderStream.ignoreBOM#

• Typ: <boolean>

Der Wert ist true, wenn das Dekodierungsergebnis das Byte Order Mark enthält.

textDecoderStream.readable#

• Typ: <ReadableStream>

textDecoderStream.writable#

• Typ: <WritableStream>

Klasse: CompressionStream#

new CompressionStream(format)#

• format <string> Einer der Werte 'deflate', 'deflate-raw', 'gzip' oder 'brotli'.

compressionStream.readable#

• Typ: <ReadableStream>

compressionStream.writable#

• Typ: <WritableStream>

Klasse: DecompressionStream#

new DecompressionStream(format)#

• format <string> Einer der Werte 'deflate', 'deflate-raw', 'gzip' oder 'brotli'.

decompressionStream.readable#

• Typ: <ReadableStream>

decompressionStream.writable#

• Typ: <WritableStream>

Dienstprogramme zur Stream-Nutzung#

Die Dienstprogrammfunktionen für Stream-Konsumenten bieten gängige Optionen zum Konsumieren von Streams.

Der Zugriff erfolgt über

import {
  arrayBuffer,
  blob,
  buffer,
  json,
  text,
} from 'node:stream/consumers';
const {
  arrayBuffer,
  blob,
  buffer,
  json,
  text,
} = require('node:stream/consumers');
copy

streamConsumers.arrayBuffer(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit einem ArrayBuffer aufgelöst, der den vollständigen Inhalt des Streams enthält.

import { arrayBuffer } from 'node:stream/consumers';
import { Readable } from 'node:stream';
import { TextEncoder } from 'node:util';

const encoder = new TextEncoder();
const dataArray = encoder.encode('hello world from consumers!');

const readable = Readable.from(dataArray);
const data = await arrayBuffer(readable);
console.log(`from readable: ${data.byteLength}`);
// Prints: from readable: 76
const { arrayBuffer } = require('node:stream/consumers');
const { Readable } = require('node:stream');
const { TextEncoder } = require('node:util');

const encoder = new TextEncoder();
const dataArray = encoder.encode('hello world from consumers!');
const readable = Readable.from(dataArray);
arrayBuffer(readable).then((data) => {
  console.log(`from readable: ${data.byteLength}`);
  // Prints: from readable: 76
});
copy

streamConsumers.blob(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit einem <Blob> aufgelöst, der den vollständigen Inhalt des Streams enthält.

import { blob } from 'node:stream/consumers';

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
const data = await blob(readable);
console.log(`from readable: ${data.size}`);
// Prints: from readable: 27
const { blob } = require('node:stream/consumers');

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
blob(readable).then((data) => {
  console.log(`from readable: ${data.size}`);
  // Prints: from readable: 27
});
copy

streamConsumers.buffer(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit einem <Buffer> aufgelöst, der den vollständigen Inhalt des Streams enthält.

import { buffer } from 'node:stream/consumers';
import { Readable } from 'node:stream';
import { Buffer } from 'node:buffer';

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
const data = await buffer(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 27
const { buffer } = require('node:stream/consumers');
const { Readable } = require('node:stream');
const { Buffer } = require('node:buffer');

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
buffer(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 27
});
copy

streamConsumers.bytes(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit einem <Uint8Array> aufgelöst, der den vollständigen Inhalt des Streams enthält.

import { bytes } from 'node:stream/consumers';
import { Readable } from 'node:stream';
import { Buffer } from 'node:buffer';

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
const data = await bytes(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 27
const { bytes } = require('node:stream/consumers');
const { Readable } = require('node:stream');
const { Buffer } = require('node:buffer');

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
bytes(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 27
});
copy

streamConsumers.json(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit dem Inhalt des Streams aufgelöst, der als UTF-8-kodierter String geparst und dann durch JSON.parse() verarbeitet wurde.

import { json } from 'node:stream/consumers';
import { Readable } from 'node:stream';

const items = Array.from(
  {
    length: 100,
  },
  () => ({
    message: 'hello world from consumers!',
  }),
);

const readable = Readable.from(JSON.stringify(items));
const data = await json(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 100
const { json } = require('node:stream/consumers');
const { Readable } = require('node:stream');

const items = Array.from(
  {
    length: 100,
  },
  () => ({
    message: 'hello world from consumers!',
  }),
);

const readable = Readable.from(JSON.stringify(items));
json(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 100
});
copy

streamConsumers.text(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Gibt zurück: <Promise> Wird mit dem Inhalt des Streams aufgelöst, der als UTF-8-kodierter String geparst wurde.

import { text } from 'node:stream/consumers';
import { Readable } from 'node:stream';

const readable = Readable.from('Hello world from consumers!');
const data = await text(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 27
const { text } = require('node:stream/consumers');
const { Readable } = require('node:stream');

const readable = Readable.from('Hello world from consumers!');
text(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 27
});
copy