Node.js v21.7.2 ドキュメント

概要#

WHATWG Streams 標準 (または "web streams") は、ストリーミングデータを処理するための API を定義します。これは Node.js Streams API に似ていますが、後で登場し、多くの JavaScript 環境でストリーミングデータの "標準" API になっています。

3つの主要なオブジェクト型があります。

• ReadableStream - ストリーミングデータのソースを表します。
• WritableStream - ストリーミングデータの宛先を表します。
• TransformStream - ストリーミングデータを変換するためのアルゴリズムを表します。

ReadableStream の例#

この例では、現在の performance.now() タイムスタンプを 1 秒ごとに永遠にプッシュするシンプルな ReadableStream を作成します。非同期イテラブルを使用して、ストリームからデータを読み取ります。

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

API#

クラス: ReadableStream#

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

• underlyingSource <Object>
  • start <Function> ReadableStream が作成されたときにすぐに呼び出されるユーザー定義関数。
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • 戻り値: undefined または undefined で解決される Promise。
  • pull <Function> ReadableStream 内部キューが満杯でないときに繰り返し呼び出されるユーザー定義関数。操作は同期または非同期である可能性があります。非同期の場合、以前に返された Promise が解決されるまで、関数は再度呼び出されません。
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • 戻り値: undefined で解決される Promise。
  • cancel <Function> ReadableStream がキャンセルされたときに呼び出されるユーザー定義関数。
    • reason <any>
    • 戻り値: undefined で解決される Promise。
  • type <string> 'bytes' または undefined である必要があります。
  • autoAllocateChunkSize <number> type が 'bytes' に等しい場合にのみ使用されます。ゼロ以外の値に設定すると、ビューバッファが ReadableByteStreamController.byobRequest に自動的に割り当てられます。設定されていない場合、デフォルトリーダー ReadableStreamDefaultReader を介してデータを転送するために、ストリームの内部キューを使用する必要があります。
• strategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>

readableStream.locked#

• 型: <boolean> この <ReadableStream> のアクティブなリーダーが存在する場合に true に設定されます。

readableStream.locked プロパティはデフォルトで false であり、ストリームのデータを消費するアクティブなリーダーが存在する間は true に切り替わります。

readableStream.cancel([reason])#

• reason <any>
• 戻り値: キャンセルが完了したら、undefined で解決される Promise。

readableStream.getReader([options])#

• options <Object>
  • mode <string> 'byob' または undefined
• 戻り値: <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

readableStream.locked が true になるようにします。

readableStream.pipeThrough(transform[, options])#

• transform <Object>
  • readable <ReadableStream> transform.writable が、この ReadableStream から受け取った可能性のある変更されたデータをプッシュする ReadableStream。
  • writable <WritableStream> この ReadableStream のデータが書き込まれる WritableStream。
• options <Object>
  • preventAbort <boolean> true の場合、この ReadableStream のエラーによって transform.writable が中止されることはありません。
  • preventCancel <boolean> true の場合、宛先 transform.writable のエラーによって、この ReadableStream がキャンセルされることはありません。
  • preventClose <boolean> true の場合、この ReadableStream を閉じても、transform.writable が閉じられることはありません。
  • signal <AbortSignal> <AbortController> を使用してデータ転送をキャンセルできるようにします。
• 戻り値: transform.readable からの <ReadableStream>。

この <ReadableStream> を、transform 引数で提供された <ReadableStream> と <WritableStream> のペアに接続し、この <ReadableStream> からのデータが transform.writable に書き込まれ、場合によっては変換され、transform.readable にプッシュされるようにします。パイプラインが構成されると、transform.readable が返されます。

パイプ操作がアクティブな間、readableStream.locked が true になります。

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: Aconst {
  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> この ReadableStream のデータが書き込まれる <WritableStream>。
• options <Object>
  • preventAbort <boolean> true の場合、この ReadableStream のエラーによって destination がアボートされることはありません。
  • preventCancel <boolean> true の場合、destination のエラーによってこの ReadableStream がキャンセルされることはありません。
  • preventClose <boolean> true の場合、この ReadableStream を閉じても destination が閉じられることはありません。
  • signal <AbortSignal> <AbortController> を使用してデータ転送をキャンセルできるようにします。
• 戻り値: undefined で満たされた Promise

パイプ操作がアクティブな間、readableStream.locked が true になります。

readableStream.tee()#

• 戻り値: <ReadableStream[]>

この ReadableStream のデータが転送される新しい <ReadableStream> インスタンスのペアを返します。それぞれが同じデータを受信します。

readableStream.locked が true になるようにします。

readableStream.values([options])#

• options <Object>
  • 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()); copy

非同期イテレーション#

<ReadableStream> オブジェクトは、for await 構文を使用して非同期イテレータプロトコルをサポートします。

import { Buffer } from 'node:buffer';

const stream = new ReadableStream(getSomeSource());

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

非同期イテレータは、終了するまで <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]); copy

ReadableStream.from(iterable)#

• iterable <Iterable> Symbol.asyncIterator または Symbol.iterator イテラブルプロトコルを実装するオブジェクト。

イテラブルから新しい <ReadableStream> を作成するユーティリティメソッド。

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

クラス: ReadableStreamDefaultReader#

デフォルトでは、引数なしで readableStream.getReader() を呼び出すと、ReadableStreamDefaultReader のインスタンスが返されます。デフォルトリーダーは、ストリームを通過するデータのチャンクを不透明な値として扱い、<ReadableStream> が一般的に任意の JavaScript 値で動作できるようにします。

new ReadableStreamDefaultReader(stream)#

• stream <ReadableStream>

指定された <ReadableStream> にロックされている新しい <ReadableStreamDefaultReader> を作成します。

readableStreamDefaultReader.cancel([reason])#

• reason <any>
• 戻り値: undefined で解決される Promise。

<ReadableStream> をキャンセルし、基になるストリームがキャンセルされたときに満たされる Promise を返します。

readableStreamDefaultReader.closed#

• タイプ: <Promise> 関連付けられた <ReadableStream> が閉じられたときに undefined で満たされるか、ストリームがエラーになるか、ストリームが閉じる前にリーダーのロックが解除された場合に拒否されます。

readableStreamDefaultReader.read()#

• 戻り値: オブジェクトで満たされた Promise
  • value <any>
  • done <boolean>

基になる <ReadableStream> から次のデータチャンクを要求し、データが利用可能になったときにデータで満たされる Promise を返します。

readableStreamDefaultReader.releaseLock()#

基になる <ReadableStream> に対するこのリーダーのロックを解除します。

クラス: ReadableStreamBYOBReader#

ReadableStreamBYOBReader は、バイト指向の <ReadableStream> (ReadableStream が作成されたときに underlyingSource.type が 'bytes' に設定された状態で作成されたもの) の代替コンシューマーです。

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

new ReadableStreamBYOBReader(stream)#

• stream <ReadableStream>

指定された <ReadableStream> にロックされている新しい ReadableStreamBYOBReader を作成します。

readableStreamBYOBReader.cancel([reason])#

• reason <any>
• 戻り値: undefined で解決される Promise。

<ReadableStream> をキャンセルし、基になるストリームがキャンセルされたときに満たされる Promise を返します。

readableStreamBYOBReader.closed#

• タイプ: <Promise> 関連付けられた <ReadableStream> が閉じられたときに undefined で満たされるか、ストリームがエラーになるか、ストリームが閉じる前にリーダーのロックが解除された場合に拒否されます。

readableStreamBYOBReader.read(view[, options])#

• view <Buffer> | <TypedArray> | <DataView>
• options <Object>
  • min <number> 設定した場合、返された Promise は、min 個の要素が利用可能になるとすぐに満たされます。設定しない場合、Promise は少なくとも 1 つの要素が利用可能になると満たされます。
• 戻り値: オブジェクトで満たされた Promise
  • value <TypedArray> | <DataView>
  • done <boolean>

基になる <ReadableStream> から次のデータチャンクを要求し、データが利用可能になったときにデータで満たされる Promise を返します。

このメソッドにプールされた <Buffer> オブジェクトインスタンスを渡さないでください。プールされた Buffer オブジェクトは、Buffer.allocUnsafe() または Buffer.from() を使用して作成されるか、さまざまな node:fs モジュールのコールバックによって頻繁に返されます。これらのタイプの Buffer は、プールされたすべての Buffer インスタンスからのすべてのデータを含む共有の基になる <ArrayBuffer> オブジェクトを使用します。 Buffer、<TypedArray>、または <DataView> が readableStreamBYOBReader.read() に渡されると、ビューの基になる ArrayBuffer がデタッチされ、その ArrayBuffer に存在する可能性のある既存のすべてのビューが無効になります。これはアプリケーションに壊滅的な結果をもたらす可能性があります。

readableStreamBYOBReader.releaseLock()#

基になる <ReadableStream> に対するこのリーダーのロックを解除します。

クラス: ReadableStreamDefaultController#

すべての <ReadableStream> には、ストリームの内部状態とキューの管理を担当するコントローラーがあります。 ReadableStreamDefaultController は、バイト指向ではない ReadableStream のデフォルトのコントローラー実装です。

readableStreamDefaultController.close()#

このコントローラーが関連付けられている <ReadableStream> を閉じます。

readableStreamDefaultController.desiredSize#

• タイプ: <number>

<ReadableStream> のキューを埋めるために残っているデータ量を返します。

readableStreamDefaultController.enqueue([chunk])#

• chunk <any>

新しいデータチャンクを <ReadableStream> のキューに追加します。

readableStreamDefaultController.error([error])#

• error <any>

エラーを通知し、<ReadableStream> をエラーにして閉じます。

クラス: ReadableByteStreamController#

すべての <ReadableStream> は、ストリームのキューの内部状態と管理を担当するコントローラーを持っています。ReadableByteStreamController は、バイト指向の ReadableStream 用です。

readableByteStreamController.byobRequest#

• 型: <ReadableStreamBYOBRequest>

readableByteStreamController.close()#

このコントローラーが関連付けられている <ReadableStream> を閉じます。

readableByteStreamController.desiredSize#

• タイプ: <number>

<ReadableStream> のキューを埋めるために残っているデータ量を返します。

readableByteStreamController.enqueue(chunk)#

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

新しいデータチャンクを <ReadableStream> のキューに追加します。

readableByteStreamController.error([error])#

• error <any>

エラーを通知し、<ReadableStream> をエラーにして閉じます。

クラス: ReadableStreamBYOBRequest#

バイト指向ストリームで ReadableByteStreamController を使用し、ReadableStreamBYOBReader を使用する場合、readableByteStreamController.byobRequest プロパティは、現在の読み取りリクエストを表す ReadableStreamBYOBRequest インスタンスへのアクセスを提供します。このオブジェクトは、読み取りリクエストを埋めるために提供された ArrayBuffer/TypedArray へのアクセスを取得するために使用され、データが提供されたことを通知するメソッドを提供します。

readableStreamBYOBRequest.respond(bytesWritten)#

• bytesWritten <number>

readableStreamBYOBRequest.view に bytesWritten バイト数が書き込まれたことを通知します。

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

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

• underlyingSink <Object>
  • start <Function> WritableStream が作成された直後に呼び出されるユーザー定義関数。
    • controller <WritableStreamDefaultController>
    • 戻り値: undefined または undefined で解決される Promise。
  • write <Function> データチャンクが WritableStream に書き込まれたときに呼び出されるユーザー定義関数。
    • chunk <any>
    • controller <WritableStreamDefaultController>
    • 戻り値: undefined で解決される Promise。
  • close <Function> WritableStream が閉じられたときに呼び出されるユーザー定義関数。
    • 戻り値: undefined で解決される Promise。
  • abort <Function> WritableStream を強制的に閉じるために呼び出されるユーザー定義関数。
    • reason <any>
    • 戻り値: undefined で解決される Promise。
  • type <any> type オプションは将来の使用のために予約されており、必ず undefined でなければなりません。
• strategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>

writableStream.abort([reason])#

• reason <any>
• 戻り値: undefined で解決される Promise。

WritableStream を強制的に終了します。キューに入っているすべての書き込みはキャンセルされ、関連する Promise は拒否されます。

writableStream.close()#

• 戻り値: undefined で解決される Promise。

追加の書き込みが予想されない場合に WritableStream を閉じます。

writableStream.getWriter()#

• 戻り値: <WritableStreamDefaultWriter>

WritableStream にデータを書き込むために使用できる新しいライターインスタンスを作成して返します。

writableStream.locked#

• 型: <boolean>

writableStream.locked プロパティは、デフォルトでは false であり、この WritableStream にアクティブなライターがアタッチされている間は true に切り替えられます。

postMessage() による転送#

<WritableStream> インスタンスは、<MessagePort> を使用して転送できます。

const stream = new WritableStream(getWritableSinkSomehow());

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

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

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

クラス: WritableStreamDefaultWriter#

new WritableStreamDefaultWriter(stream)#

• stream <WritableStream>

指定された WritableStream にロックされた新しい WritableStreamDefaultWriter を作成します。

writableStreamDefaultWriter.abort([reason])#

• reason <any>
• 戻り値: undefined で解決される Promise。

WritableStream を強制的に終了します。キューに入っているすべての書き込みはキャンセルされ、関連する Promise は拒否されます。

writableStreamDefaultWriter.close()#

• 戻り値: undefined で解決される Promise。

追加の書き込みが予想されない場合に WritableStream を閉じます。

writableStreamDefaultWriter.closed#

• 型: <Promise> 関連付けられた <WritableStream> が閉じられたときに undefined で解決されるか、ストリームがエラーになった場合、またはストリームが閉じ終わる前にライターのロックが解放された場合に拒否されます。

writableStreamDefaultWriter.desiredSize#

• タイプ: <number>

<WritableStream> のキューを埋めるために必要なデータ量。

writableStreamDefaultWriter.ready#

• 型: <Promise> ライターを使用する準備ができたときに undefined で解決されます。

writableStreamDefaultWriter.releaseLock()#

基になる <ReadableStream> に対するこのライターのロックを解放します。

writableStreamDefaultWriter.write([chunk])#

• chunk: <any>
• 戻り値: undefined で解決される Promise。

<WritableStream> のキューに新しいデータチャンクを追加します。

クラス: WritableStreamDefaultController#

WritableStreamDefaultController は、<WritableStream> の内部状態を管理します。

writableStreamDefaultController.error([error])#

• error <any>

WritableStream データの処理中にエラーが発生したことを通知するためにユーザーコードによって呼び出されます。呼び出されると、<WritableStream> が中止され、現在保留中の書き込みがキャンセルされます。

writableStreamDefaultController.signal#

• 型: <AbortSignal> <WritableStream> が中止されたときに保留中の書き込みまたは閉じる操作をキャンセルするために使用できる AbortSignal。

クラス: 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(),
]); copy

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

• transformer <Object>
  • start <Function> TransformStream が作成された直後に呼び出されるユーザー定義関数。
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined または undefined で解決される Promise
  • transform <Function> transformStream.writable に書き込まれたデータチャンクを受け取り、変更する可能性があり、その後、それを transformStream.readable に転送するユーザー定義関数。
    • chunk <any>
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined で解決される Promise。
  • flush <Function> TransformStream の書き込み側が閉じられる直前に呼び出され、変換プロセスの終了を通知するユーザー定義関数。
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined で解決される Promise。
  • 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>

transformStream.readable#

• 型: <ReadableStream>

transformStream.writable#

• 型: <WritableStream>

postMessage() による転送#

<TransformStream> インスタンスは、<MessagePort> を使用して転送できます。

const stream = new TransformStream();

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

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

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

クラス: TransformStreamDefaultController#

TransformStreamDefaultController は、TransformStream の内部状態を管理します。

transformStreamDefaultController.desiredSize#

• タイプ: <number>

読み取り側のキューを満たすために必要なデータ量。

transformStreamDefaultController.enqueue([chunk])#

• chunk <any>

読み取り側のキューにデータのチャンクを追加します。

transformStreamDefaultController.error([reason])#

• reason <any>

変換データの処理中にエラーが発生したことを読み取り側と書き込み側の両方に通知し、両側が強制的に閉じられます。

transformStreamDefaultController.terminate()#

トランスポートの読み取り側を閉じ、書き込み側をエラーで強制的に閉じます。

クラス: ByteLengthQueuingStrategy#

new ByteLengthQueuingStrategy(init)#

• init <Object>
  • highWaterMark <number>

byteLengthQueuingStrategy.highWaterMark#

• タイプ: <number>

byteLengthQueuingStrategy.size#

• 型: <Function>
  • chunk <any>
  • 戻り値: <number>

クラス: CountQueuingStrategy#

new CountQueuingStrategy(init)#

• init <Object>
  • highWaterMark <number>

countQueuingStrategy.highWaterMark#

• タイプ: <number>

countQueuingStrategy.size#

• 型: <Function>
  • chunk <any>
  • 戻り値: <number>

クラス: TextEncoderStream#

new TextEncoderStream()#

新しい TextEncoderStream インスタンスを作成します。

textEncoderStream.encoding#

• 型: <string>

TextEncoderStream インスタンスでサポートされているエンコーディング。

textEncoderStream.readable#

• 型: <ReadableStream>

textEncoderStream.writable#

• 型: <WritableStream>

クラス: TextDecoderStream#

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

• encoding <string> この TextDecoder インスタンスがサポートする encoding を識別します。デフォルト: 'utf-8'。
• options <Object>
  • fatal <boolean> デコードの失敗が致命的な場合は true。
  • ignoreBOM <boolean> true の場合、TextDecoderStream はデコード結果にバイトオーダーマークを含めます。false の場合、バイトオーダーマークは出力から削除されます。このオプションは、encoding が 'utf-8'、'utf-16be'、または 'utf-16le' の場合にのみ使用されます。デフォルト: false。

新しい TextDecoderStream インスタンスを作成します。

textDecoderStream.encoding#

• 型: <string>

TextDecoderStream インスタンスでサポートされているエンコーディング。

textDecoderStream.fatal#

• 型: <boolean>

デコードエラーが TypeError をスローする場合は、値が true になります。

textDecoderStream.ignoreBOM#

• 型: <boolean>

デコード結果にバイトオーダーマークが含まれる場合、値は true になります。

textDecoderStream.readable#

• 型: <ReadableStream>

textDecoderStream.writable#

• 型: <WritableStream>

クラス: CompressionStream#

new CompressionStream(format)#

• format <string> 'deflate'、'deflate-raw'、または 'gzip' のいずれか。

compressionStream.readable#

• 型: <ReadableStream>

compressionStream.writable#

• 型: <WritableStream>

クラス: DecompressionStream#

new DecompressionStream(format)#

• format <string> 'deflate'、'deflate-raw'、または 'gzip' のいずれか。

decompressionStream.readable#

• 型: <ReadableStream>

decompressionStream.writable#

• 型: <WritableStream>

ユーティリティコンシューマー#

ユーティリティコンシューマー関数は、ストリームを消費するための一般的なオプションを提供します。

これらは以下を使用してアクセスされます

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>
• 戻り値: <Promise> ストリームのすべての内容を含む ArrayBuffer で履行します。

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: 76const { 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>
• 戻り値: <Promise> ストリームのすべての内容を含む <Blob> で履行します。

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: 27const { 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>
• 戻り値: <Promise> ストリームのすべての内容を含む <Buffer> で履行します。

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: 27const { 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.json(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> ストリームの内容を UTF-8 エンコードされた文字列として解析し、JSON.parse() を通して渡します。

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: 100const { 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>
• 戻り値: <Promise> ストリームの内容を UTF-8 エンコードされた文字列として解析します。

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: 27const { 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