Readable class

new Readable(options?: ReadableOptions<Readable>)

Parameter

Adalah true setelah 'close' telah dipancarkan.

closed: boolean

Nilai Properti

Adalah true setelah readable.destroy() telah dipanggil.

destroyed: boolean

Nilai Properti

Mengembalikan kesalahan jika aliran telah dihancurkan dengan kesalahan.

errored: null | Error

Nilai Properti

Apakah true jika aman untuk memanggil baca, yang berarti aliran belum dihancurkan atau dipancarkan 'error' atau 'end'.

readable: boolean

Nilai Properti

Mengembalikan apakah aliran dihancurkan atau error sebelum dipancarkan 'end'.

readableAborted: boolean

Nilai Properti

Mengembalikan apakah 'data' telah dipancarkan.

readableDidRead: boolean

Nilai Properti

Pengambil untuk properti encoding aliran tertentu Readable . Properti encoding dapat diatur menggunakan metode setEncoding .

readableEncoding: null | BufferEncoding

Nilai Properti

Menjadi true ketika 'end' peristiwa dipancarkan.

readableEnded: boolean

Nilai Properti

Properti ini mencerminkan status Readable aliran saat ini seperti yang dijelaskan di bagian Tiga status .

readableFlowing: null | boolean

Nilai Properti

Mengembalikan nilai lulus highWaterMark saat membuat ini Readable.

readableHighWaterMark: number

Nilai Properti

Properti ini berisi jumlah byte (atau objek) dalam antrean yang siap dibaca. Nilai tersebut memberikan data introspeksi mengenai status highWaterMark.

readableLength: number

Nilai Properti

Pengambil untuk properti objectMode aliran tertentu Readable .

readableObjectMode: boolean

Nilai Properti

function addListener(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function addListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']

readable.compose(s) setara dengan stream.compose(readable, s).

Metode ini juga memungkinkan untuk AbortSignal disediakan, yang akan menghancurkan aliran yang disusun saat dibatalkan.

Lihat stream.compose(...streams) untuk informasi lebih lanjut.

function compose(stream: WritableStream | WritableStream<any> | TransformStream<any, any> | (source: any) => void, options?: Abortable): Duplex

Parameter

Mengembalikan

aliran yang disusun dengan aliran stream.

Hancurkan alirannya. Secara opsional memancarkan peristiwa 'error' , dan memancarkan 'close' peristiwa (kecuali diatur emitClose ke false). Setelah panggilan ini, aliran yang dapat dibaca akan melepaskan sumber daya internal apa pun dan panggilan berikutnya akan push() diabaikan.

Setelah destroy() dipanggil, panggilan lebih lanjut akan menjadi no-op dan tidak ada kesalahan lebih lanjut kecuali dari _destroy() yang dapat dipancarkan sebagai 'error'.

Pelaksana tidak boleh mengganti metode ini, melainkan menerapkan readable._destroy().

function destroy(error?: Error): Readable

Parameter

Mengembalikan

Metode ini mengembalikan aliran baru dengan potongan batas pertama yang dijatuhkan dari awal.

function drop(limit: number, options?: Abortable): Readable

Parameter

Mengembalikan

aliran dengan potongan batas yang dijatuhkan sejak awal.

function emit(eventName: string | symbol, args: any[]): boolean

Parameter

Mengembalikan

function emit<E>(eventName: E, args: ReadableEventMap[E]): boolean

Parameter

Mengembalikan

Metode ini mirip dengan Array.prototype.every dan memanggil fn pada setiap potongan dalam aliran untuk memeriksa apakah semua nilai pengembalian yang ditunggu adalah nilai kebenaran untuk fn. Setelah panggilan fn pada awaitnilai pengembalian chunk ed palsu, aliran dihancurkan dan janji dipenuhi dengan false. Jika semua panggilan fn pada potongan mengembalikan nilai yang benar, janji dipenuhi dengan true.

function every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<boolean>

Parameter

Mengembalikan

Janji yang mengevaluasi jika trueFN mengembalikan nilai yang benar untuk setiap potongan.

Metode ini memungkinkan pemfilteran aliran. Untuk setiap potongan dalam aliran, fungsi fn akan dipanggil dan jika mengembalikan nilai yang benar, potongan akan diteruskan ke aliran hasil. Jika fungsi fn mengembalikan promise - promise tersebut akan ed await.

function filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable

Parameter

Mengembalikan

aliran yang disaring dengan predikat fn.

function find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<any>

Parameter

Mengembalikan

Metode ini mirip dengan Array.prototype.find dan memanggil fn pada setiap potongan dalam aliran untuk menemukan potongan dengan nilai kebenaran untuk fn. Setelah nilai pengembalian panggilan fn yang ditunggu-tunggu adalah kebenaran, aliran dihancurkan dan janji dipenuhi dengan nilai yang fn mengembalikan nilai yang benar. Jika semua panggilan fn pada potongan mengembalikan nilai palsu, janji dipenuhi dengan undefined.

function find<T>(fn: (data: any, options?: Abortable) => data, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<undefined | T>

Parameter

Mengembalikan

Janji yang mengevaluasi ke potongan pertama yang dievaluasi FN dengan nilai kebenaran, atau undefined jika tidak ada elemen yang ditemukan.

Metode ini mengembalikan aliran baru dengan menerapkan callback yang diberikan ke setiap bagian aliran dan kemudian meratakan hasilnya.

Dimungkinkan untuk mengembalikan aliran atau iterable atau asinkron lain yang dapat diulang dari fn dan aliran hasil akan digabungkan (diratakan) ke dalam aliran yang dikembalikan.

function flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Readable

Parameter

Mengembalikan

aliran yang dipetakan datar dengan fungsi fn.

Metode ini memungkinkan iterasi aliran. Untuk setiap potongan dalam aliran, fungsi fn akan dipanggil. Jika fungsi fn mengembalikan promise - promise tersebut akan ed await.

Metode ini berbeda dari for await...of loop karena dapat secara opsional memproses potongan secara bersamaan. Selain itu, iterasi forEach hanya dapat dihentikan dengan melewati signal opsi dan membatalkan AbortController terkait sementara for await...of dapat dihentikan dengan break atau return. Dalam kedua kasus tersebut, aliran akan dihancurkan.

Metode ini berbeda dengan mendengarkan 'data' peristiwa karena menggunakan readable peristiwa dalam mesin yang mendasarinya dan dapat membatasi jumlah panggilan fn bersamaan.

function forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<void>

Parameter

Mengembalikan

janji ketika aliran selesai.

Metode utilitas untuk membuat Aliran yang Dapat Dibaca dari iterator.

static function from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions<Readable>): Readable

Parameter

Mengembalikan

Metode utilitas untuk membuat dari Readable web ReadableStream.

static function fromWeb(readableStream: ReadableStream<any>, options?: Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">): Readable

Parameter

Mengembalikan

Mengembalikan apakah streaming telah dibaca dari atau dibatalkan.

static function isDisturbed(stream: ReadableStream<any> | ReadableStream): boolean

Parameter

Mengembalikan

Metode ini readable.isPaused() mengembalikan status operasi saat ini dari .Readable Ini digunakan terutama oleh mekanisme yang mendasari metode ini readable.pipe() . Dalam kebanyakan kasus umum, tidak akan ada alasan untuk menggunakan metode ini secara langsung.

const readable = new stream.Readable();

readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false

function isPaused(): boolean

Mengembalikan

Iterator yang dibuat dengan metode ini memberi pengguna opsi untuk membatalkan penghancuran aliran jika for await...of loop keluar oleh return, break, atau throw, atau jika iterator harus menghancurkan aliran jika aliran memancarkan kesalahan selama iterasi.

function iterator(options?: ReadableIteratorOptions): AsyncIterator<any, undefined, any>

Parameter

Mengembalikan

function listenerCount(eventName: string | symbol, listener?: (args: any[]) => void): number

Parameter

Mengembalikan

function listenerCount<E>(eventName: E, listener?: (args: ReadableEventMap[E]) => void): number

Parameter

Mengembalikan

function listeners(eventName: string | symbol): (args: any[]) => void[]

Parameter

Mengembalikan

function listeners<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parameter

Mengembalikan

Metode ini memungkinkan pemetaan melalui aliran. Fungsi fn akan dipanggil untuk setiap potongan dalam aliran. Jika fungsi fn mengembalikan promise - promise tersebut akan ed awaitsebelum diteruskan ke aliran hasil.

function map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable

Parameter

Mengembalikan

aliran yang dipetakan dengan fungsi fn.

function off(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function off<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

function on(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function on<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

function once(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function once<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

Metode ini readable.pause() akan menyebabkan aliran dalam mode mengalir berhenti memancarkan 'data' peristiwa, beralih dari mode mengalir. Data apa pun yang tersedia akan tetap berada di buffer internal.

const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes of data.`);
  readable.pause();
  console.log('There will be no additional data for 1 second.');
  setTimeout(() => {
    console.log('Now data will start flowing again.');
    readable.resume();
  }, 1000);
});

Metode ini readable.pause() tidak berpengaruh jika ada 'readable' pendengar peristiwa.

function pause(): Readable

Mengembalikan

function prependListener(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function prependListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

function prependOnceListener(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function prependOnceListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

function push(chunk: any, encoding?: BufferEncoding): boolean

Parameter

Mengembalikan

function rawListeners(eventName: string | symbol): (args: any[]) => void[]

Parameter

Mengembalikan

function rawListeners<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parameter

Mengembalikan

Metode ini readable.read() membaca data dari buffer internal dan mengembalikannya. Jika tidak ada data yang tersedia untuk dibaca, dikembalikan. null Secara default, data dikembalikan sebagai Buffer objek kecuali pengkodean telah ditentukan menggunakan metode atau readable.setEncoding() aliran beroperasi dalam mode objek.

Argumen opsional size menentukan jumlah byte tertentu untuk dibaca. Jika size byte tidak tersedia untuk dibaca, null akan dikembalikan kecuali aliran telah berakhir, dalam hal ini semua data yang tersisa di buffer internal akan dikembalikan.

Jika size argumen tidak ditentukan, semua data yang terkandung dalam buffer internal akan dikembalikan.

Argumen size harus kurang dari atau sama dengan 1 GiB.

Metode ini readable.read() hanya boleh dipanggil pada Readable aliran yang beroperasi dalam mode dijeda. Dalam mode mengalir, readable.read() dipanggil secara otomatis sampai buffer internal benar-benar terkuras.

const readable = getReadableStreamSomehow();

// 'readable' may be triggered multiple times as data is buffered in
readable.on('readable', () => {
  let chunk;
  console.log('Stream is readable (new data received in buffer)');
  // Use a loop to make sure we read all currently available data
  while (null !== (chunk = readable.read())) {
    console.log(`Read ${chunk.length} bytes of data...`);
  }
});

// 'end' will be triggered once when there is no more data available
readable.on('end', () => {
  console.log('Reached end of stream.');
});

Setiap panggilan ke readable.read() mengembalikan potongan data, atau null. Potongan-potongan itu tidak tergabung. Perulangan while diperlukan untuk menggunakan semua data yang saat ini berada di buffer. Saat membaca file .read() besar dapat mengembalikan null, setelah mengkonsumsi semua konten buffer sejauh ini, tetapi masih ada lebih banyak data yang akan datang belum buffer. Dalam hal ini, peristiwa baru 'readable' akan dipancarkan ketika ada lebih banyak data di buffer. Akhirnya 'end' event akan dipancarkan ketika tidak ada lagi data yang akan datang.

Oleh karena itu, untuk membaca seluruh konten file dari readable, perlu untuk mengumpulkan potongan di beberapa 'readable' peristiwa:

const chunks = [];

readable.on('readable', () => {
  let chunk;
  while (null !== (chunk = readable.read())) {
    chunks.push(chunk);
  }
});

readable.on('end', () => {
  const content = chunks.join('');
});

Aliran Readable dalam mode objek akan selalu mengembalikan satu item dari panggilan ke readable.read(size), terlepas dari nilai size argumen.

Jika metode mengembalikan readable.read() sebagian data, 'data' peristiwa juga akan dipancarkan.

Panggilan yang dibaca setelah 'end' peristiwa dipancarkan akan kembali null. Tidak ada kesalahan runtime yang akan diangkat.

function read(size?: number): any

Parameter

Mengembalikan

Metode ini memanggil fn pada setiap potongan aliran secara berurutan, meneruskannya hasil dari perhitungan pada elemen sebelumnya. Ini mengembalikan janji untuk nilai akhir pengurangan.

Jika tidak ada nilai awal yang disediakan, potongan pertama aliran digunakan sebagai nilai awal. Jika aliran kosong, janji ditolak dengan properti dengan TypeErrorERR_INVALID_ARGS kode.

Fungsi peredam mengulangi elemen aliran demi elemen yang berarti tidak ada parameter konkurensi atau paralelisme. Untuk melakukan pengurangan secara bersamaan, Anda dapat mengekstrak fungsi asinkron ke readable.map metode.

function reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>

Parameter

Mengembalikan

janji untuk nilai akhir pengurangan.

function reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>

Parameter

Mengembalikan

function removeAllListeners(eventName?: string | symbol): Readable

Parameter

Mengembalikan

function removeAllListeners<E>(eventName?: E): Readable

Parameter

Mengembalikan

function removeListener(eventName: string | symbol, listener: (args: any[]) => void): Readable

Parameter

Mengembalikan

function removeListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): Readable

Parameter

Mengembalikan

Metode ini readable.resume() menyebabkan aliran yang dijeda Readable secara eksplisit untuk melanjutkan peristiwa pemancaran 'data' , mengalihkan aliran ke mode mengalir.

Metode ini readable.resume() dapat digunakan untuk sepenuhnya mengonsumsi data dari aliran tanpa benar-benar memproses data tersebut:

getReadableStreamSomehow()
  .resume()
  .on('end', () => {
    console.log('Reached the end, but did not read anything.');
  });

Metode ini readable.resume() tidak berpengaruh jika ada 'readable' pendengar peristiwa.

function resume(): Readable

Mengembalikan

Metode ini readable.setEncoding() mengatur pengkodean karakter untuk data yang dibaca dari Readable aliran.

Secara default, tidak ada pengkodean yang ditetapkan dan data aliran akan dikembalikan sebagai Buffer objek. Mengatur pengodean menyebabkan data aliran dikembalikan sebagai string pengodean yang ditentukan, bukan sebagai Buffer objek. Misalnya, memanggil readable.setEncoding('utf8') akan menyebabkan data output ditafsirkan sebagai data UTF-8, dan diteruskan sebagai string. Memanggil readable.setEncoding('hex') akan menyebabkan data dikodekan dalam format string heksadesimal.

Aliran Readable akan menangani karakter multi-byte yang dikirimkan melalui aliran dengan benar yang akan didekodekan secara tidak benar jika hanya ditarik dari aliran sebagai Buffer objek.

const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
  assert.equal(typeof chunk, 'string');
  console.log('Got %d characters of string data:', chunk.length);
});

function setEncoding(encoding: BufferEncoding): Readable

Parameter

Mengembalikan

Metode ini mirip dengan Array.prototype.some dan memanggil fn pada setiap potongan dalam aliran hingga nilai pengembalian yang ditunggu-tunggu adalah true (atau nilai kebenaran apa pun). Setelah panggilan fn pada awaitnilai pengembalian chunk ed benar, aliran dihancurkan dan janji dipenuhi dengan true. Jika tidak ada panggilan fn pada potongan yang mengembalikan nilai yang benar, janji itu dipenuhi dengan false.

function some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<boolean>

Parameter

Mengembalikan

Janji yang mengevaluasi jika trueFN mengembalikan nilai kebenaran untuk setidaknya satu potongan.

Metode ini mengembalikan aliran baru dengan potongan batas pertama.

function take(limit: number, options?: Abortable): Readable

Parameter

Mengembalikan

aliran dengan potongan batas yang diambil.

Metode ini memungkinkan dengan mudah mendapatkan konten aliran.

Karena metode ini membaca seluruh aliran ke dalam memori, metode ini meniadakan manfaat aliran. Ini ditujukan untuk interoperabilitas dan kenyamanan, bukan sebagai cara utama untuk mengonsumsi streaming.

function toArray(options?: Abortable): Promise<any[]>

Parameter

Mengembalikan

Janji yang berisi array dengan konten aliran.

Metode utilitas untuk membuat web ReadableStream dari .Readable

static function toWeb(streamReadable: ReadableStream, options?: ReadableToWebOptions): ReadableStream<any>

Parameter

Mengembalikan

Metode ini readable.unpipe() melepaskan aliran yang Writable sebelumnya terpasang menggunakan metode pipa .

Jika tidak destination ditentukan, maka semua pipa terlepas.

Jika ditentukan destination , tetapi tidak ada pipa yang disiapkan untuk itu, maka metode tersebut tidak melakukan apa-apa.

import fs from 'node:fs';
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
  console.log('Stop writing to file.txt.');
  readable.unpipe(writable);
  console.log('Manually close the file stream.');
  writable.end();
}, 1000);

function unpipe(destination?: WritableStream): Readable

Parameter

Mengembalikan

Melewati chunk sebagai null sinyal akhir aliran (EOF) dan berperilaku sama dengan readable.push(null), setelah itu tidak ada lagi data yang dapat ditulis. Sinyal EOF diletakkan di ujung buffer dan data buffer apa pun akan tetap disiram.

Metode ini readable.unshift() mendorong sebagian data kembali ke buffer internal. Ini berguna dalam situasi tertentu di mana aliran dikonsumsi oleh kode yang perlu "membatalkan konsumsi" sejumlah data yang telah ditarik secara optimis dari sumbernya, sehingga data dapat diteruskan ke pihak lain.

Metode ini stream.unshift(chunk) tidak dapat dipanggil setelah 'end' peristiwa dipancarkan atau kesalahan runtime akan dilemparkan.

Pengembang yang sering menggunakan stream.unshift() harus mempertimbangkan untuk beralih ke penggunaan Transform aliran sebagai gantinya. Lihat bagian untuk API for stream implementers informasi lebih lanjut.

// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
import { StringDecoder } from 'node:string_decoder';
function parseHeader(stream, callback) {
  stream.on('error', callback);
  stream.on('readable', onReadable);
  const decoder = new StringDecoder('utf8');
  let header = '';
  function onReadable() {
    let chunk;
    while (null !== (chunk = stream.read())) {
      const str = decoder.write(chunk);
      if (str.includes('\n\n')) {
        // Found the header boundary.
        const split = str.split(/\n\n/);
        header += split.shift();
        const remaining = split.join('\n\n');
        const buf = Buffer.from(remaining, 'utf8');
        stream.removeListener('error', callback);
        // Remove the 'readable' listener before unshifting.
        stream.removeListener('readable', onReadable);
        if (buf.length)
          stream.unshift(buf);
        // Now the body of the message can be read from the stream.
        callback(null, header, stream);
        return;
      }
      // Still reading the header.
      header += str;
    }
  }
}

Tidak seperti push, stream.unshift(chunk) tidak akan mengakhiri proses membaca dengan mengatur ulang status pembacaan internal aliran. Hal ini dapat menyebabkan hasil yang tidak terduga jika readable.unshift() dipanggil selama pembacaan (yaitu dari dalam implementasi _read pada aliran kustom). Mengikuti panggilan ke readable.unshift() dengan dorongan langsung akan mengatur ulang status pembacaan dengan tepat, namun yang terbaik adalah menghindari panggilan readable.unshift() saat dalam proses melakukan pembacaan.

function unshift(chunk: any, encoding?: BufferEncoding)

Parameter

Sebelum Node.js 0.10, streaming tidak mengimplementasikan seluruh node:stream API modul seperti yang ditentukan saat ini. (Lihat Compatibility untuk informasi lebih lanjut.)

Saat menggunakan pustaka Node.js lama yang memancarkan 'data' peristiwa dan memiliki metode jeda yang hanya bersifat pemberitahuan, metode tersebut readable.wrap() dapat digunakan untuk membuat Readable aliran yang menggunakan aliran lama sebagai sumber datanya.

Jarang perlu digunakan readable.wrap() tetapi metode ini telah disediakan sebagai kenyamanan untuk berinteraksi dengan aplikasi dan perpustakaan Node.js lama.

import { OldReader } from './old-api-module.js';
import { Readable } from 'node:stream';
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);

myReader.on('readable', () => {
  myReader.read(); // etc.
});

function wrap(stream: ReadableStream): Readable

Parameter

Mengembalikan

function [asyncIterator](): AsyncIterator<any, undefined, any>

Mengembalikan

AsyncIterator untuk mengkonsumsi aliran sepenuhnya.

Saat --experimental-stream-iter bendera diaktifkan, Readable streaming mengimplementasikan Stream.toAsyncStreamable protokol, memungkinkan konsumsi yang efisien oleh stream/iter API.

Ini menyediakan iterator asinkron batch yang menguras buffer internal aliran ke dalam Uint8Array[] batch, mengamortisasi overhead Promise per potongan dari jalur standar Symbol.asyncIterator . Untuk aliran mode byte, potongan dihasilkan secara langsung sebagai Buffer instans (yang merupakan Uint8Array subkelas). Untuk aliran mode objek atau yang dikodekan, setiap potongan dinormalisasi sebelum Uint8Array pengelompokan.

Iterator yang dikembalikan ditandai sebagai sumber yang divalidasi, sehingga from() melewatinya tanpa normalisasi tambahan.

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

const readable = new Readable({
  read() { this.push('hello'); this.push(null); },
});

// Readable is automatically consumed via toAsyncStreamable
console.log(await text(from(readable))); // 'hello'

Tanpa --experimental-stream-iter bendera, memanggil metode ini melempar ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Mengembalikan

Mengembalikan array yang mencantumkan peristiwa di mana pemancar telah mendaftarkan pendengar.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Mengembalikan

Diwarisi dari Stream.eventNames

Mengembalikan nilai pendengar maks saat ini untuk EventEmitter yang diatur oleh emitter.setMaxListeners(n) atau default ke events.defaultMaxListeners.

function getMaxListeners(): number

Mengembalikan

Diwarisi dari Stream.getMaxPendengar

function pipe<T>(destination: T, options?: PipeOptions): T

Parameter

Mengembalikan

Diwarisi dari Stream.pipe

Secara default EventEmitterakan mencetak peringatan jika lebih dari 10 pendengar ditambahkan untuk peristiwa tertentu. Ini adalah default yang berguna yang membantu menemukan kebocoran memori. Metode emitter.setMaxListeners() memungkinkan batas untuk dimodifikasi untuk instans EventEmitter spesifik ini. Nilai dapat diatur ke Infinity (atau 0) untuk menunjukkan jumlah listener yang tidak terbatas.

Mengembalikan referensi ke EventEmitter, sehingga panggilan dapat ditautkan.

function setMaxListeners(n: number): Readable

Parameter

Mengembalikan

Diwarisi dari Stream.setMaxPendengar

Metode ini Symbol.for('nodejs.rejection') dipanggil jika penolakan janji terjadi saat memancarkan peristiwa dan captureRejections diaktifkan pada emitor. Dimungkinkan untuk digunakan events.captureRejectionSymbol sebagai pengganti Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parameter

Diwarisi dari Stream.__@captureRejectionSymbol@180