Обзор

Стандарт потоков WHATWG (или "потоки веб-приложений") определяет API для обработки потоковых данных. Он похож на API потоков Node.js Streams, но появился позже и стал "стандартным" API для потоковых данных во многих средах JavaScript.

Существует три основных типа объектов

• ReadableStream - Представляет источник потоковых данных.
• WritableStream - Представляет место назначения для потоковых данных.
• TransformStream - Представляет алгоритм преобразования потоковых данных.

Пример ReadableStream

Этот пример создаёт простой ReadableStream , который бесконечно выводит текущую отметку времени performance.now() раз в секунду. Для чтения данных из потока используется асинхронный итерируемый объект.

Модули MJS

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

Модули CJS

const {
  ReadableStream
} = require('stream/web');

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

const {
  performance
} = require('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);
})();

API

Класс: ReadableStream

new ReadableStream([underlyingSource [, strategy]])

• underlyingSource <Объект>
  • start <Функция> Определяемая пользователем функция, которая вызывается сразу при создании ReadableStream.
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • Возвращает: undefined или промис, выполненный с undefined.
  • pull <Функция> Определяемая пользователем функция, которая вызывается повторно, когда внутренняя очередь ReadableStream не заполнена. Операция может быть синхронной или асинхронной. Если асинхронная, функция не будет вызвана снова, пока не будет выполнен ранее возвращённый промис.
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • Возвращает: Промис, выполненный с undefined.
  • cancel <Функция> Определяемая пользователем функция, которая вызывается, когда ReadableStream отменяется.
    • reason <любое>
    • Возвращает: Промис, выполненный с undefined.
  • type <строка> Должно быть 'bytes' или undefined.
  • autoAllocateChunkSize <число> Используется только когда type равно 'bytes'.
• strategy <Объект>
  • highWaterMark <число> Максимальный размер внутренней очереди перед применением обратной связи о недостатке ресурсов.
  • size <Функция> Определяемая пользователем функция, используемая для определения размера каждого фрагмента данных.
    • chunk <любое>
    • Возвращает: <число>

readableStream.locked

• Тип: <булево> Устанавливается в true, если для этого <ReadableStream> есть активный читатель.

Свойство readableStream.locked по умолчанию false, и переключается на true, пока активен читатель, потребляющий данные потока.

readableStream.cancel([reason])

• reason <любое>
• Возвращает: Промис, выполненный с undefined после завершения отмены.

readableStream.getReader([options])

• options <Объект>
  • mode <строка> 'byob' или undefined
• Возвращает: <ReadableStreamDefaultReader> | <ReadableStreamBYOBReader>

Модули MJS

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

const stream = new ReadableStream();

const reader = stream.getReader();

console.log(await reader.read());

Модули CJS

const { ReadableStream } = require('stream/web');

const stream = new ReadableStream();

const reader = stream.getReader();

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

Вызывает readableStream.locked для true.

readableStream.pipeThrough(transform[, options])

• transform <Объект>
  • readable <ReadableStream> ReadableStream , которому transform.writable будет передавать потенциально измененные данные, полученные от этого ReadableStream.
  • writable <WritableStream> WritableStream , в который будут записаны данные этого ReadableStream.
• options <Объект>
  • preventAbort <булево> При true, ошибки в этом ReadableStream не приведут к прерыванию transform.writable.
  • preventCancel <булево> При true, ошибки в целевом transform.writable не приведут к отмене этого ReadableStream.
  • preventClose <булево> При true, закрытие этого ReadableStream не приведёт к закрытию transform.writable.
  • signal <AbortSignal> Позволяет отменить передачу данных с помощью <AbortController>.
• Возвращает: <ReadableStream> Из transform.readable.

Подключает этот <ReadableStream> к паре <ReadableStream> и <WritableStream>, указанной в аргументе transform, таким образом, что данные из этого <ReadableStream> записываются в transform.writable, возможно, преобразуются, а затем передаются в transform.readable. После настройки конвейера возвращается transform.readable.

Вызывает readableStream.locked для true во время активной операции конвейера.

Модули MJS

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

Модули CJS

const {
  ReadableStream,
  TransformStream,
} = require('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);
})();

readableStream.pipeTo(destination, options)

• destination <WritableStream> <WritableStream>, в который будут записаны данные этого ReadableStream.
• options <Объект>
  • preventAbort <булево> При true, ошибки в этом ReadableStream не приведут к прерыванию transform.writable.
  • preventCancel <булево> При true, ошибки в целевом transform.writable не приведут к отмене этого ReadableStream.
  • preventClose <булево> При true, закрытие этого ReadableStream не приведёт к закрытию transform.writable.
  • signal <AbortSignal> Позволяет отменить передачу данных с помощью <AbortController>.
• Возвращает: Промис, выполненный с undefined

Вызывает readableStream.locked для true во время активной операции конвейера.

readableStream.tee()

• Возвращает: <ReadableStream[]>

Возвращает пару новых экземпляров <ReadableStream>, в которые будут перенаправлены данные этого ReadableStream. Каждый получит те же данные.

Вызывает readableStream.locked для true.

readableStream.values([options])

• options <Объект>
  • preventCancel <boolean> Когда true, предотвращает закрытие <ReadableStream>, когда асинхронный итератор прерывается неожиданно. По умолчанию: false

Создаёт и возвращает асинхронный итератор, пригодный для потребления данных этого ReadableStream.

Приводит readableStream.locked к true в то время, пока активен асинхронный итератор.

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

Асинхронная итерация

Объект <ReadableStream> поддерживает протокол асинхронного итератора, используя for await синтаксис.

import { Buffer } from 'buffer';

const stream = new ReadableStream(getSomeSource());

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

Асинхронный итератор будет потреблять <ReadableStream> до его завершения.

По умолчанию, если асинхронный итератор завершается преждевременно (через break, return, или throw), <ReadableStream> будет закрыт. Для предотвращения автоматического закрытия <ReadableStream>, используйте метод readableStream.values() для получения асинхронного итератора и установите опцию preventCancel в значение true.

<ReadableStream> не должен быть заблокирован (то есть, у него не должно быть активного читателя). Во время асинхронной итерации <ReadableStream> будет заблокирован.

Передача с помощью postMessage()

Экземпляр <ReadableStream> может быть передан с помощью <MessagePort>.

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

Класс: ReadableStreamDefaultReader

По умолчанию, вызов readableStream.getReader() без аргументов вернёт экземпляр ReadableStreamDefaultReader. По умолчанию, читатель рассматривает блоки данных, проходящие через поток, как непрозрачные значения, что позволяет <ReadableStream> работать с любыми JavaScript-значениями.

new ReadableStreamDefaultReader(stream)

• stream <ReadableStream>

Создаёт новый <ReadableStreamDefaultReader>, заблокированный для данного <ReadableStream>.

readableStreamDefaultReader.cancel([reason])

• reason <любой>
• Возвращает: промис, выполненный с undefined.

Отменяет <ReadableStream> и возвращает промис, который выполняется, когда базовый поток был отменён.

readableStreamDefaultReader.closed

• Тип: <Промис> Выполняется с undefined при закрытии связанного <ReadableStream> или при разблокировании этого читателя.

readableStreamDefaultReader.read()

• Возвращает: промис, выполненный с объектом:
  • value <ArrayBuffer>
  • done <boolean>

Запрашивает следующий блок данных из базового <ReadableStream> и возвращает промис, который выполняется с данными, как только они станут доступны.

readableStreamDefaultReader.releaseLock()

Освобождает блокировку этого читателя на базовом <ReadableStream>.

Класс: ReadableStreamBYOBReader

ReadableStreamBYOBReader — альтернативный потребитель для потоков байтов <ReadableStream> (те, которые созданы с underlyingSource.type равным 'bytes', когда ReadableStream был создан).

BYOB — сокращение от "bring your own buffer". Это шаблон, который позволяет более эффективно читать данные байтов, избегая лишних копирований.

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

new ReadableStreamBYOBReader(stream)

• stream <ReadableStream>

Создаёт новый ReadableStreamBYOBReader , заблокированный для данного <ReadableStream>.

readableStreamBYOBReader.cancel([reason])

• reason <любой>
• Возвращает: промис, выполненный с undefined.

Отменяет <ReadableStream> и возвращает промис, который выполняется, когда базовый поток был отменён.

readableStreamBYOBReader.closed

• Тип: <Промис> Выполняется с undefined при закрытии связанного <ReadableStream> или при разблокировании этого читателя.

readableStreamBYOBReader.read(view)

• view <Буфер> | <Массив_типов> | <DataView>
• Возвращает: промис, выполненный с объектом:
  • value <ArrayBuffer>
  • done <boolean>

Запрашивает следующий блок данных из базового <ReadableStream> и возвращает промис, который выполняется с данными, как только они станут доступны.

Не передавайте в этот метод пул объектов <Буфер>. Пулы объектов Buffer создаются с помощью Buffer.allocUnsafe(), или Buffer.from(), или часто возвращаются различными обратными вызовами модуля fs. Эти типы Buffer используют общий базовый объект <ArrayBuffer>, который содержит все данные всех экземпляров пула Buffer . Когда в readableStreamBYOBReader.read() передаётся Buffer, <Массив_типов> или <DataView>, базовый ArrayBuffer представления открепляется, делая все существующие представления этого ArrayBuffer недействительными. Это может иметь катастрофические последствия для вашего приложения.

readableStreamBYOBReader.releaseLock()

Освобождает блокировку этого читателя на базовом <ReadableStream>.

Класс: ReadableStreamDefaultController

Каждый <ReadableStream> имеет контроллер, который отвечает за внутреннее состояние и управление очередью потока. ReadableStreamDefaultController — это контроллер по умолчанию для ReadableStream потоков, которые не ориентированы на байты.

readableStreamDefaultController.close()

Закрывает <ReadableStream>, к которому связан этот контроллер.

readableStreamDefaultController.desiredSize

• Тип: <число>

Возвращает оставшийся объём данных для заполнения очереди <ReadableStream>.

readableStreamDefaultController.enqueue(chunk)

• chunk <любой>

Добавляет новый фрагмент данных в очередь <ReadableStream>.

readableStreamDefaultController.error(error)

• error <любой>

Сигнализирует об ошибке, которая приводит к ошибке и закрытию <ReadableStream>.

Класс: ReadableByteStreamController

У каждого <ReadableStream> есть контроллер, который отвечает за внутреннее состояние и управление очередью потока. Контроллер ReadableByteStreamController предназначен для потоков байтов ReadableStream.

readableByteStreamController.byobRequest

• Тип: <ReadableStreamBYOBRequest>

readableByteStreamController.close()

Закрывает <ReadableStream>, к которому относится этот контроллер.

readableByteStreamController.desiredSize

• Тип: <число>

Возвращает количество данных, оставшихся для заполнения очереди <ReadableStream>.

readableByteStreamController.enqueue(chunk)

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

Добавляет новый фрагмент данных в очередь <ReadableStream>.

readableByteStreamController.error(error)

• error <любой>

Сигнализирует об ошибке, которая приводит к ошибке и закрытию <ReadableStream>.

Класс: ReadableStreamBYOBRequest

При использовании ReadableByteStreamController в потоках байтов и при использовании ReadableStreamBYOBReader, свойство readableByteStreamController.byobRequest предоставляет доступ к экземпляру ReadableStreamBYOBRequest, который представляет текущий запрос на чтение. Объект используется для доступа к ArrayBuffer/TypedArray, предоставленным для заполнения запроса на чтение, и предоставляет методы для сигнализации о предоставлении данных.

readableStreamBYOBRequest.respond(bytesWritten)

• bytesWritten <число>

Сигнализирует, что байты в количестве bytesWritten были записаны в readableStreamBYOBRequest.view.

readableStreamBYOBRequest.respondWithNewView(view)

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

Сигнализирует, что запрос выполнен записью байтов в новый Buffer, TypedArray, или DataView.

readableStreamBYOBRequest.view

• Тип: <Buffer> | <TypedArray> | <DataView>

Класс: WritableStream

WritableStream — это место назначения, куда отправляются данные потока.

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

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

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

new WritableStream([underlyingSink[, strategy]])

• underlyingSink <Объект>
  • start <Функция> Пользовательская функция, которая вызывается немедленно при создании WritableStream.
    • controller <WritableStreamDefaultController>
    • Возвращает: undefined или обещание, выполненное с undefined.
  • write <Функция> Пользовательская функция, которая вызывается, когда фрагмент данных был записан в WritableStream.
    • chunk <любой>
    • controller <WritableStreamDefaultController>
    • Возвращает: Обещание, выполненное с undefined.
  • close <Функция> Пользовательская функция, вызываемая при закрытии WritableStream.
    • Возвращает: Обещание, выполненное с undefined.
  • abort <Функция> Пользовательская функция, вызываемая для прерывания WritableStream.
    • reason <любой>
    • Возвращает: Обещание, выполненное с undefined.
  • type <любой> Опция type зарезервирована для будущего использования и должна быть неопределённой.
• strategy <Объект>
  • highWaterMark <число> Максимальный размер внутренней очереди до применения обратной зависимости от давления.
  • size <Функция> Пользовательская функция, используемая для определения размера каждого фрагмента данных.
    • chunk <любой>
    • Возвращает: <число>

writableStream.abort([reason])

• reason <любой>
• Возвращает: Обещание, выполненное с undefined.

Прерывает WritableStream. Все ожидающие записи будут отменены, и соответствующие обещания будут отклонены.

writableStream.close()

• Возвращает: Обещание, выполненное с undefined.

Закрывает WritableStream при отсутствии дополнительных ожидаемых записей.

writableStream.getWriter()

• Возвращает: <WritableStreamDefaultWriter>

Создает и создает новый экземпляр писателя, который можно использовать для записи данных в WritableStream.

writableStream.locked

• Тип: <булево>

Свойство writableStream.locked по умолчанию false, и изменяется на true при наличии активного писателя, подключенного к этому WritableStream.

Передача с помощью postMessage()

Экземпляр <WritableStream> можно передать с помощью <MessagePort>.

const stream = new WritableStream(getWritableSinkSomehow());

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

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

port2.postMessage(stream, [stream]);

Класс: WritableStreamDefaultWriter

new WritableStreamDefaultWriter(stream)

• stream <WritableStream>

Создает новый WritableStreamDefaultWriter, который заблокирован для данного WritableStream.

writableStreamDefaultWriter.abort([reason])

• reason <any>
• Возвращает: промис, выполненный с undefined.

Прерывает WritableStream. Все ожидающие записи будут отменены, а связанные с ними промисы будут отклонены.

Закрыть

• Возвращает: промис, выполненный с undefined.

Закрывает WritableStream, когда больше нет ожидаемых записей.

Закрыто

• Тип: промис, который выполняется с undefined, когда связанный <WritableStream> закрывается или блокировка этого писателя снимается.

Размер, требуемый

• Тип: <number>

Количество данных, необходимое для заполнения очереди <WritableStream>.

Готов

• тип: промис, который выполняется с undefined когда писатель готов к использованию.

Освободить блокировку

Освобождает блокировку этого писателя на основе <ReadableStream>.

Записать

• chunk: <any>
• Возвращает: промис, выполненный с undefined.

Добавляет новый фрагмент данных в очередь <WritableStream>.

Класс: WritableStreamDefaultController

WritableStreamDefaultController управляет внутренним состоянием <WritableStream>.

Причина отмены

• Тип: <any> Значение reason переданное в writableStream.abort().

Ошибка

• error <any>

Вызывается кодом пользователя, чтобы указать, что произошла ошибка при обработке WritableStream данных. При вызове <WritableStream> будет прервана, а текущие ожидающие записи отменены.

Сигнал

• Тип: <AbortSignal> AbortSignal который можно использовать для отмены ожидающих операций записи или закрытия, когда <WritableStream> прерывается.

Класс: TransformStream

TransformStream состоит из <ReadableStream> и <WritableStream>, которые соединены таким образом, что данные, записанные в WritableStream принимаются и, возможно, преобразуются, прежде чем быть добавлены в очередь ReadableStream.

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

Создать TransformStream()

• transformer <Object>
  • start <Function> Пользовательская функция, которая вызывается сразу после создания TransformStream.
    • controller <TransformStreamDefaultController>
    • Возвращает: undefined или промис, выполненный с undefined
  • transform <Function> Пользовательская функция, которая получает и, возможно, изменяет фрагмент данных, записанный в transformStream.writable, перед передачей его в transformStream.readable.
    • chunk <any>
    • controller <TransformStreamDefaultController>
    • Возвращает: промис, выполненный с undefined.
  • flush <Function> Пользовательская функция, которая вызывается непосредственно перед закрытием записывающей стороны TransformStream, сигнализируя об окончании процесса преобразования.
    • controller <TransformStreamDefaultController>
    • Возвращает: промис, выполненный с undefined.
  • readableType <any> Опция readableType зарезервирована для будущих применений и должна быть undefined.
  • writableType <any> Опция writableType зарезервирована для будущих применений и должна быть undefined.
• writableStrategy <Object>
  • highWaterMark <number> Максимальный размер внутренней очереди перед применением обратной связи.
  • size <Function> Пользовательская функция для определения размера каждого фрагмента данных.
    • chunk <any>
    • Возвращает: <number>
• readableStrategy <Object>
  • highWaterMark <number> Максимальный размер внутренней очереди перед применением обратной связи.
  • size <Function> Пользовательская функция для определения размера каждого фрагмента данных.
    • chunk <any>
    • Возвращает: <number>

Чтение

• Тип: <ReadableStream>

Запись

• Тип: <WritableStream>

Передача с помощью postMessage()

Экземпляр <TransformStream> может быть передан с помощью <MessagePort>.

const stream = new TransformStream();

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

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

port2.postMessage(stream, [stream]);

Класс: TransformStreamDefaultController

TransformStreamDefaultController управляет внутренним состоянием TransformStream.

Требуемый размер

• Тип: <number>

Количество данных, необходимое для заполнения очереди со стороны чтения.

В очереди

• chunk <any>

Добавляет фрагмент данных в очередь со стороны чтения.

Ошибка

• reason <any>

Сигнализирует обеим сторонам, что произошла ошибка при обработке данных преобразования, вызывая резкое закрытие обеих сторон.

Прервать

Закрывает сторону чтения канала и вызывает резкое закрытие стороны записи с ошибкой.

Класс: ByteLengthQueuingStrategy

new ByteLengthQueuingStrategy(options)

• options <Объект>
  • highWaterMark <число>

byteLengthQueuingStrategy.highWaterMark

• Тип: <число>

byteLengthQueuingStrategy.size

• Тип: <Функция>
  • chunk <любой>
  • Возвращает: <число>

Класс: CountQueuingStrategy

new CountQueuingStrategy(options)

• options <Объект>
  • highWaterMark <число>

countQueuingStrategy.highWaterMark

• Тип: <число>

countQueuingStrategy.size

• Тип: <Функция>
  • chunk <любой>
  • Возвращает: <число>

Класс: TextEncoderStream

new TextEncoderStream()

Создает новый экземпляр TextEncoderStream.

textEncoderStream.encoding

• Тип: <строка>

Кодировка, поддерживаемая экземпляром TextEncoderStream.

textEncoderStream.readable

• Тип: <ReadableStream>

textEncoderStream.writable

• Тип: <WritableStream>

Класс: TextDecoderStream

new TextDecoderStream([encoding[, options]])

• encoding <строка> Идентифицирует кодировку, которую поддерживает этот экземпляр TextDecoder. По умолчанию: 'utf-8'.
• options <Объект>
  • fatal <логическое> true если ошибки декодирования приводят к исключению.
  • ignoreBOM <логическое> Если true, экземпляр TextDecoderStream будет включать байтовый порядок в декодированный результат. Если false, байтовый порядок будет удален из вывода. Этот параметр используется только тогда, когда encoding равен 'utf-8', 'utf-16be' или 'utf-16le'. По умолчанию: false.

Создает новый экземпляр TextDecoderStream.

textDecoderStream.encoding

• Тип: <строка>

Кодировка, поддерживаемая экземпляром TextDecoderStream.

textDecoderStream.fatal

• Тип: <логическое>

Значение будет true если ошибки декодирования приводят к выбросу исключения TypeError.

textDecoderStream.ignoreBOM

• Тип: <логическое>

Значение будет true если результат декодирования будет включать байтовый порядок.

textDecoderStream.readable

• Тип: <ReadableStream>

textDecoderStream.writable

• Тип: <WritableStream>

Функции-потребители служебных функций

Функции-потребители служебных функций предоставляют общие параметры для потребления потоков.

К ним можно обратиться, используя:

Модули MJS

import {
  arrayBuffer,
  blob,
  json,
  text,
} from 'node:stream/consumers';

Модули CJS

const {
  arrayBuffer,
  blob,
  json,
  text,
} = require('stream/consumers');

streamConsumers.arrayBuffer(stream)

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Возвращает: <Promise> Выполняется с ArrayBuffer, содержащим полное содержимое потока.

streamConsumers.blob(stream)

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Возвращает: <Promise> Выполняется с <Blob>, содержащим полное содержимое потока.

streamConsumers.buffer(stream)

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Возвращает: <Promise> Выполняется с <Buffer>, содержащим полное содержимое потока.

streamConsumers.json(stream)

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Возвращает: <Promise> Выполняется с содержимым потока, интерпретированным как строка UTF-8, которая затем передаётся через JSON.parse().

streamConsumers.text(stream)

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• Возвращает: <Promise> Выполняется со содержимым потока, интерпретированным как строка UTF-8.