ReadableStream

Hinweis: Dieses Feature ist verfügbar in Web Workers.

Das ReadableStream-Interface der Streams API repräsentiert einen lesbaren Datenstrom von Byte-Daten. Die Fetch API bietet eine konkrete Instanz eines ReadableStream über die body-Eigenschaft eines Response-Objekts.

ReadableStream ist ein übertragbares Objekt.

Konstruktor

ReadableStream()

Erstellt und gibt ein lesbares Stream-Objekt aus den angegebenen Handlern zurück.

Instanz-Eigenschaften

ReadableStream.locked Nur lesbar

Gibt einen boolean zurück, der anzeigt, ob der lesbare Strom an einen Leser gebunden ist oder nicht.

Statische Methoden

ReadableStream.from() Experimentell

Gibt ReadableStream von einem bereitgestellten iterierbaren oder asynchronen iterierbaren Objekt zurück, wie z.B. ein Array, ein Set, ein asynchroner Generator und so weiter.

Instanz-Methoden

ReadableStream.cancel()

Gibt ein Promise zurück, das aufgelöst wird, wenn der Stream abgebrochen wird. Das Aufrufen dieser Methode signalisiert ein Interesse-Verlust des Verbrauchers am Stream. Das übergebene reason-Argument wird der zugrunde liegenden Quelle gegeben, die es möglicherweise verwendet oder nicht.

ReadableStream.getReader()

Erstellt einen Leser und sperrt den Stream für ihn. Während der Stream gesperrt ist, kann kein anderer Leser erworben werden, bis dieser freigegeben wird.

ReadableStream.pipeThrough()

Bietet eine kaskadierbare Möglichkeit, den aktuellen Stream durch einen Transformationsstream oder ein beliebiges anderes schreibbares/lesbares Paar zu leiten.

ReadableStream.pipeTo()

Leitet den aktuellen ReadableStream zu einem gegebenen WritableStream und gibt ein Promise zurück, das erfüllt wird, wenn der Piping-Prozess erfolgreich abgeschlossen ist, oder abgelehnt wird, wenn Fehler aufgetreten sind.

ReadableStream.tee()

Die tee-Methode [verzweigt] (https://streams.spec.whatwg.org/#tee-a-readable-stream) diesen lesbaren Stream und gibt ein zwei-Elemente-Array zurück, das die beiden resultierenden Zweige als neue ReadableStream-Instanzen enthält. Jeder dieser Streams erhält die gleichen eingehenden Daten.

Asynchrone Iteration

ReadableStream implementiert das asynchrone iterierbare Protokoll. Dies ermöglicht die asynchrone Iteration über die Chunks in einem Stream mithilfe der for await...of-Syntax:

js
const stream = new ReadableStream(getSomeSource());

for await (const chunk of stream) {
  // Do something with each 'chunk'
}

Der asynchrone Iterator verbraucht den Stream, bis er keine Daten mehr hat oder anderweitig endet. Die Schleife kann auch frühzeitig aufgrund eines break-, throw- oder return-Befehls beendet werden.

Während der Iteration ist der Stream gesperrt, um zu verhindern, dass andere Verbraucher einen Leser erwerben (Versuche, über einen bereits gesperrten Stream zu iterieren, werfen einen TypeError). Diese Sperre wird freigegeben, wenn die Schleife endet.

Standardmäßig wird der Stream beim Beenden der Schleife ebenfalls abgebrochen, sodass er nicht mehr verwendet werden kann. Um den Stream nach dem Beenden der Schleife weiterhin zu verwenden, geben Sie { preventCancel: true } an die values()-Methode des Streams weiter:

js
for await (const chunk of stream.values({ preventCancel: true })) {
  // Do something with 'chunk'
  break;
}
// Acquire a reader for the stream and continue reading ...

Beispiele

Fetch-Stream

Im folgenden Beispiel wird eine künstliche Response erstellt, um HTML-Fragmente, die von einer anderen Ressource abgerufen wurden, an den Browser zu streamen.

Es demonstriert die Verwendung eines ReadableStream in Kombination mit einem Uint8Array.

js
fetch("https://www.example.org")
  .then((response) => response.body)
  .then((rb) => {
    const reader = rb.getReader();

    return new ReadableStream({
      start(controller) {
        // The following function handles each data chunk
        function push() {
          // "done" is a Boolean and value a "Uint8Array"
          reader.read().then(({ done, value }) => {
            // If there is no more data to read
            if (done) {
              console.log("done", done);
              controller.close();
              return;
            }
            // Get the data and send it to the browser via the controller
            controller.enqueue(value);
            // Check chunks by logging to the console
            console.log(done, value);
            push();
          });
        }

        push();
      },
    });
  })
  .then((stream) =>
    // Respond with our stream
    new Response(stream, { headers: { "Content-Type": "text/html" } }).text(),
  )
  .then((result) => {
    // Do things with result
    console.log(result);
  });

Konvertieren eines Iterators oder asynchronen Iterators in einen Stream

Die statische Methode from() kann einen Iterator, wie einen Array oder Map, oder einen (asynchronen) Iterator in einen lesbaren Stream konvertieren:

js
const myReadableStream = ReadableStream.from(iteratorOrAsyncIterator);

In Browsern, die die from()-Methode nicht unterstützen, können Sie stattdessen Ihren eigenen benutzerdefinierten lesbaren Stream erstellen, um das gleiche Ergebnis zu erzielen:

js
function iteratorToStream(iterator) {
  return new ReadableStream({
    async pull(controller) {
      const { value, done } = await iterator.next();

      if (value) {
        controller.enqueue(value);
      }
      if (done) {
        controller.close();
      }
    },
  });
}

Warnung: Dieses Beispiel geht davon aus, dass der Rückgabewert (value wenn done true ist), falls vorhanden, ebenfalls ein Chunk ist, der eingereiht werden soll. Einige Iterator-APIs können den Rückgabewert für andere Zwecke verwenden. Möglicherweise müssen Sie den Code anpassen, basierend auf der API, mit der Sie interagieren.

Asynchrone Iteration eines Streams mit for await...of

Dieses Beispiel zeigt, wie Sie die fetch()-Antwort mit einer for await...of-Schleife verarbeiten können, um durch die ankommenden Chunks zu iterieren.

js
const response = await fetch("https://www.example.org");
let total = 0;

// Iterate response.body (a ReadableStream) asynchronously
for await (const chunk of response.body) {
  // Do something with each chunk
  // Here we just accumulate the size of the response.
  total += chunk.length;
}

// Do something with the total
console.log(total);

Spezifikationen

Specification
Streams Standard
# rs-class

Browser-Kompatibilität

BCD tables only load in the browser

Siehe auch