Readable class

new Readable(options?: ReadableOptions<Readable>)

Parameter

Es ist true danach 'close' ausgestrahlt worden.

closed: boolean

Eigenschaftswert

Es ist true danach readable.destroy() aufgerufen worden.

destroyed: boolean

Eigenschaftswert

Gibt einen Fehler zurück, wenn der Strom mit einem Fehler zerstört wurde.

errored: null | Error

Eigenschaftswert

Ist true , wenn es sicher ist, gelesen zu rufen, was bedeutet, dass der Strom nicht zerstört oder ausgesandt 'error' wurde oder 'end'.

readable: boolean

Eigenschaftswert

Gibt zurück, ob der Strom vor der Aussendung 'end'zerstört oder fehlerhaft war.

readableAborted: boolean

Eigenschaftswert

Es wird bestätigt, ob 'data' ausgesandt wurde.

readableDidRead: boolean

Eigenschaftswert

Getter für die Eigenschaft encoding eines gegebenen Readable Stroms. Die Eigenschaft encoding kann mit der setEncoding-Methode gesetzt werden.

readableEncoding: null | BufferEncoding

Eigenschaftswert

Es wird zu true dem Zeitpunkt, in dem 'end' ein Ereignis ausgestrahlt wird.

readableEnded: boolean

Eigenschaftswert

Diese Eigenschaft spiegelt den aktuellen Zustand eines Readable Baches wider, wie im Abschnitt " Drei Zustände " beschrieben.

readableFlowing: null | boolean

Eigenschaftswert

Gibt beim Erstellen dieses zurück Readableden Wert von highWaterMark gegeben.

readableHighWaterMark: number

Eigenschaftswert

Diese Eigenschaft enthält die Anzahl der Bytes (oder Objekte) in der Warteschlange, die zum Lesen bereit sind. Der Wert liefert Introspektionsdaten zum Status der highWaterMark.

readableLength: number

Eigenschaftswert

Getter für die Eigenschaft objectMode eines gegebenen Readable Stroms.

readableObjectMode: boolean

Eigenschaftswert

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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) entspricht stream.compose(readable, s).

Mit diesem Verfahren kann auch ein bereitgestellt werden AbortSignal , was den komponierten Strom beim Abbruch zerstört.

Weitere Informationen finden Sie unter stream.compose(...streams).

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

Parameter

Gibt zurück

ein Bach, der mit dem Strom streamzusammengesetzt ist.

Zerstören Sie den Strom. Optional kann ein 'error' Event ausgesendet werden, und ein 'close' Event ausgesendet werden (sofern emitClose nicht auf gesetzt ist false). Nach diesem Aufruf gibt der lesbare Stream alle internen Ressourcen frei und nachfolgende Aufrufe push() werden ignoriert.

Sobald destroy() aufgerufen wurde, werden weitere Anrufe ein no-op und keine weiteren Fehler außer von _destroy() können als 'error'ausgesendet werden.

Implementatoren sollten diese Methode nicht überschreiben, sondern stattdessen implementieren readable._destroy().

function destroy(error?: Error): Readable

Parameter

Gibt zurück

Diese Methode liefert einen neuen Stream zurück, bei dem die ersten Limit-Chunks von Anfang an weggelassen wurden.

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

Parameter

Gibt zurück

Ein Stream mit Limit Chunks, der von Anfang an gefallen ist.

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

Diese Methode ähnelt und Array.prototype.every ruft fn auf jedem Chunk im Strom auf, um zu prüfen, ob alle wartenden Rückgabewerte wahrheitswürdige Werte für fn sind. Sobald ein fn-Call auf einem Chunked-Rückgabewert awaitfalsch ist, wird der Strom zerstört und das Versprechen mit falseerfüllt. Wenn alle fn-Aufrufe auf den Chunks einen wahrheitswerten Wert zurückgeben, wird das Versprechen mit trueerfüllt.

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

Parameter

Gibt zurück

Ein Versprechen, das bewertet, ob trueFN für jeden einzelnen der Chunks einen wahrheitsgemässen Wert zurückgibt.

Diese Methode ermöglicht das Filtern des Stroms. Für jeden Chunk im Strom wird die fn-Funktion aufgerufen, und wenn sie einen truthy-Wert zurückgibt, wird der Chunk an den Ergebnisstrom weitergegeben. Wenn die fn-Funktion ein Versprechen zurückgibt – dann ist awaitdieses Versprechen ed.

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

Parameter

Gibt zurück

ein Bach, der mit dem Prädikat FN gefiltert wurde.

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

Parameter

Gibt zurück

Diese Methode ähnelt und Array.prototype.find ruft auf jedem Chunk im Stream fn auf, um einen Chunk mit einem Truthy-Wert für fn zu finden. Sobald der erwartete Rückgabewert eines Fn-Calls Truthy ist, wird der Stream zerstört und das Versprechen mit einem Wert erfüllt, für den Fn einen Truthy-Wert zurückgegeben hat. Wenn alle fn-Aufrufe auf den Chunks einen falschen Wert zurückgeben, wird das Versprechen mit undefinederfüllt.

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

Parameter

Gibt zurück

Ein Versprechen, das den ersten Chunk bewertet, für den FN mit einem Truthy-Wert bewertet wurde, oder undefined wenn kein Element gefunden wurde.

Diese Methode gibt einen neuen Stream zurück, indem der gegebene Callback auf jeden Block des Streams angewendet und das Ergebnis abgeflacht wird.

Es ist möglich, einen Strom oder einen anderen iterablen oder asynchronen Iterablen von fn zurückzugeben, und die resultierenden Ströme werden in den zurückgesendeten Strom eingegliedert (abgeflacht).

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

Parameter

Gibt zurück

ein Strom, der mit der Funktion fn flach abgebildet wird.

Diese Methode ermöglicht das Iterieren eines Stroms. Für jeden Chunk im Strom wird die fn-Funktion aufgerufen. Wenn die fn-Funktion ein Versprechen zurückgibt – dann ist awaitdieses Versprechen ed.

Diese Methode unterscheidet sich von for await...of Schleifen dadurch, dass sie optional Chunks gleichzeitig verarbeiten kann. Außerdem kann eine forEach Iteration nur gestoppt werden, indem eine signal Option bestanden und der zugehörige AbortController abgebrochen wird, während for await...of mit oder returngestoppt break werden kann. In beiden Fällen wird der Strom zerstört.

Diese Methode unterscheidet sich vom Abhören des Ereignisses 'data' dadurch, dass sie das readable Ereignis in der zugrunde liegenden Maschine verwendet und die Anzahl gleichzeitiger FN-Aufrufe begrenzen kann.

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

Parameter

Gibt zurück

Ein Versprechen, wenn der Stream zu Ende ist.

Eine Utility-Methode zur Erstellung lesbarer Streams aus Iteratoren.

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

Parameter

Gibt zurück

Eine Utility-Methode zur Erstellung eines Readable aus einem Web ReadableStream.

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

Parameter

Gibt zurück

Kehrt zurück, egal ob der Stream gelesen oder abgebrochen wurde.

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

Parameter

Gibt zurück

Die Methode readable.isPaused() liefert den aktuellen Betriebszustand der Readable. Dies wird hauptsächlich vom Mechanismus genutzt, der der Methode readable.pipe() zugrunde liegt. In den meisten typischen Fällen gibt es keinen Grund, diese Methode direkt anzuwenden.

const readable = new stream.Readable();

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

function isPaused(): boolean

Gibt zurück

Der durch diese Methode erstellte Iterator gibt den Nutzern die Möglichkeit, die Zerstörung des Stroms abzubrechen, wenn die Schleife for await...of von return, break, oder throw, beendet wird, oder wenn der Iterator den Strom zerstören sollte, wenn der Strom während der Iteration einen Fehler ausstrahlt.

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

Diese Methode erlaubt die Abbildung des Stroms. Die fn-Funktion wird für jeden Chunk im Strom aufgerufen. Wenn die fn-Funktion ein Versprechen zurückgibt, wird dieses Versprechen ed sein await, bevor es an den Ergebnisstrom weitergegeben wird.

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

Parameter

Gibt zurück

ein Strom, der mit der Funktion FN abgebildet wird.

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

Die Methode readable.pause() bewirkt, dass ein Strom im Fließmodus aufhört, Ereignisse auszusenden 'data' , und aus dem Fließmodus wechselt. Alle verfügbaren Daten bleiben im internen Puffer.

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

Die Methode readable.pause() hat keine Wirkung, wenn es einen 'readable' Ereignis-Listener gibt.

function pause(): Readable

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

Die Methode readable.read() liest Daten aus dem internen Puffer und gibt sie zurück. Wenn keine Daten zum Lesen verfügbar sind, null wird sie zurückgegeben. Standardmäßig werden die Daten als Buffer Objekt zurückgegeben, es sei denn, eine Codierung wurde mit der Methode readable.setEncoding() angegeben oder der Strom arbeitet im Objektmodus.

Das optionale size Argument gibt eine bestimmte Anzahl von Bytes an, die gelesen werden sollen. Wenn size keine Bytes zum Lesen verfügbar sind, null werden sie zurückgegeben, es sei denn , der Strom ist beendet, in diesem Fall werden alle im internen Puffer verbleibenden Daten zurückgegeben.

Wenn das Argument size nicht angegeben ist, werden alle im internen Puffer enthaltenen Daten zurückgegeben.

Das Argument size muss kleiner als oder gleich 1 GiB sein.

Die Methode readable.read() sollte nur bei Readable Strömen aufgerufen werden, die im Pause-Modus arbeiten. Im Fließmodus wird automatisch aufgerufen, readable.read() bis der interne Puffer vollständig entleert ist.

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.');
});

Jeder Aufruf zu readable.read() gibt einen Datenblock zurück, oder null. Die Chunks sind nicht verkettet. Eine Schleife while ist notwendig, um alle Daten im Puffer zu konsumieren. Beim Lesen kann eine große Datei .read() zurückkommen null, wobei alle bisher gepufferten Inhalte verbraucht wurden, aber es gibt noch weitere Daten, die noch nicht gepuffert sind. In diesem Fall wird ein neues 'readable' Ereignis ausgesendet, wenn sich mehr Daten im Puffer befinden. Schließlich wird das 'end' Ereignis ausgesendet, wenn keine weiteren Daten mehr verfügbar sind.

Daher ist es notwendig, um den gesamten Inhalt einer Datei aus einem zu lesen readable, Chunks über mehrere 'readable' Ereignisse hinweg zu sammeln:

const chunks = [];

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

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

Ein Readable Stream im Objektmodus gibt immer ein einzelnes Element aus einem Aufruf zu readable.read(size)zurück, unabhängig vom Wert des Arguments size .

Wenn die Methode readable.read() einen Datenblock zurückgibt, wird auch ein Ereignis 'data' ausgesendet.

Rufen nach der Ausstrahlung des Ereignisses 'end' werden zurückgerufen null. Es wird kein Laufzeitfehler angezeigt.

function read(size?: number): any

Parameter

Gibt zurück

Diese Methode ruft fn auf jedem Abschnitt des Stroms in der Reihenfolge auf und übermittelt ihm das Ergebnis aus der Berechnung des vorherigen Elements. Es gibt ein Versprechen für den Endwert der Reduktion zurück.

Wird kein Anfangswert angegeben, wird das erste Stück des Stroms als Anfangswert verwendet. Ist der Strom leer, wird das Versprechen mit einer TypeError mit der ERR_INVALID_ARGS Code-Eigenschaft abgelehnt.

Die Reduzierfunktion iteriert den Strom Element für Element, was bedeutet, dass es keinen Nebenläufigkeitsparameter oder Parallelität gibt. Um gleichzeitig eine Reduktion durchzuführen, kann man die asynchrone Funktion in die readable.map Methode extrahieren.

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

Parameter

Gibt zurück

ein Versprechen für den Endwert der Reduktion.

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

Die Methode readable.resume() bewirkt, dass ein explizit pausierter Readable Strom wieder Ereignisse 'data' aussendet, wodurch der Strom in den Flussmodus wechselt.

Die Methode readable.resume() kann verwendet werden, um die Daten aus einem Strom vollständig zu konsumieren, ohne diese Daten tatsächlich zu verarbeiten:

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

Die Methode readable.resume() hat keine Wirkung, wenn es einen 'readable' Ereignis-Listener gibt.

function resume(): Readable

Gibt zurück

Die Methode readable.setEncoding() legt die Zeichenkodierung für die aus dem Strom Readable gelesenen Daten fest.

Standardmäßig wird keine Codierung zugewiesen und Stromdaten werden als Buffer Objekte zurückgegeben. Das Setzen einer Codierung führt dazu, dass die Stromdaten als Strings der angegebenen Codierung und nicht als Buffer Objekte zurückgegeben werden. Zum Beispiel führt ein Aufruf readable.setEncoding('utf8') dazu, dass die Ausgabedaten als UTF-8-Daten interpretiert und als Zeichenketten übermittelt werden. Ein Aufruf readable.setEncoding('hex') führt dazu, dass die Daten im hexadezimalen String-Format codiert werden.

Der Strom Readable verarbeitet korrekt Multibyte-Zeichen, die durch den Strom geliefert werden und sonst falsch decodiert würden, wenn sie einfach als Objekte aus dem Strom Buffer gezogen würden.

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

Gibt zurück

Diese Methode ist ähnlich wie Array.prototype.some und ruft fn auf jedem Chunk im Strom auf, bis der erwartete Rückgabewert (oder ein Truthy-Wert) erreicht ist true . Sobald ein FN-Call auf einen Chunk awaitEd-Rückgabewert wahrheitsgemäß ist, wird der Stream zerstört und das Versprechen mit trueerfüllt. Wenn keiner der fn-Aufrufe auf die Chunks einen wahrheitlichen Wert zurückgibt, wird das Versprechen mit falseerfüllt.

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

Parameter

Gibt zurück

Ein Versprechen, das bewertet, ob trueFN zumindest einen Truthy-Wert für mindestens einen der Chunks zurückgibt.

Diese Methode gibt einen neuen Strom mit den ersten Limit-Chunks zurück.

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

Parameter

Gibt zurück

Ein Stream mit limitierten Abschnitten.

Diese Methode ermöglicht es einfach, den Inhalt eines Stroms zu erhalten.

Da diese Methode den gesamten Strom in den Speicher liest, werden die Vorteile von Strömen aufgehoben. Es ist für Interoperabilität und Bequemlichkeit gedacht, nicht als primäre Methode, Streams zu konsumieren.

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

Parameter

Gibt zurück

ein Versprechen, das ein Array mit dem Inhalt des Stroms enthält.

Eine Utility-Methode zur Erstellung eines Webs ReadableStream aus einem Readable.

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

Parameter

Gibt zurück

Die Methode readable.unpipe() trennt einen Writable zuvor angelegten Strahl mittels Rohrmethode .

Wenn das nicht destination angegeben ist, werden alle Rohre abgetrennt.

Wenn das destination angegeben ist, aber kein Rohr dafür eingerichtet ist, bewirkt die Methode nichts.

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

Gibt zurück

Das Senden chunk als null Signale das Ende des Stroms (EOF) und verhält sich gleich wie readable.push(null), woraufhin keine weiteren Daten mehr geschrieben werden können. Das EOF-Signal wird ans Ende des Puffers gelegt und alle gepufferten Daten werden weiterhin entfernt.

Die Methode readable.unshift() drückt einen Datenblock zurück in den internen Puffer. Dies ist nützlich in bestimmten Situationen, in denen ein Strom von Code verbraucht wird, der eine bestimmte Menge an Daten "entverbrauchen" muss, die er optimistisch aus der Quelle gezogen hat, damit die Daten an eine andere Partei weitergegeben werden können.

Die Methode stream.unshift(chunk) kann nicht aufgerufen werden, nachdem das Ereignis 'end' ausgesendet wurde, sonst wird ein Laufzeitfehler ausgelöst.

Entwickler, die häufig nutzen stream.unshift() , sollten stattdessen in Erwägung ziehen, auf einen Transform Stream umzusteigen. Siehe den Abschnitt API for stream implementers für weitere Informationen.

// 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;
    }
  }
}

Im Gegensatz zu Push wird der Leseprozess nicht durch das Zurücksetzen des internen Lesezustands des Streams stream.unshift(chunk) beendet. Dies kann unerwartete Ergebnisse verursachen, wenn readable.unshift() er während eines Lesens (d. h. aus einer _read Implementierung auf einem benutzerdefinierten Stream ) aufgerufen wird. Das Folgen des Aufrufs mit readable.unshift() einem sofortigen Push setzt den Lesezustand entsprechend zurück, es ist jedoch am besten, während des Lesens einen Anruf readable.unshift() zu vermeiden.

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

Parameter

Vor Node.js 0.10 implementierten Streams nicht die gesamte node:stream Modul-API, wie sie derzeit definiert ist. (Siehe Compatibility für weitere Informationen.)

Wenn eine ältere Node.js-Bibliothek verwendet wird, die Ereignisse ausgibt 'data' und eine rein beratende Pausenmethode besitzt, kann diese readable.wrap() Methode verwendet werden, um einen Readable Strom zu erstellen, der den alten Strom als Datenquelle nutzt.

Sie wird selten notwendig readable.wrap() sein, aber die Methode wurde als Komfort für die Interaktion mit älteren Node.js-Anwendungen und Bibliotheken bereitgestellt.

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

Gibt zurück

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

Gibt zurück

AsyncIterator um den Strom vollständig zu konsumieren.

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat.

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

Gibt zurück

Geerbt von Stream.eventNames

Gibt den aktuellen Maximallistenerwert für die EventEmitter zurück, die entweder durch emitter.setMaxListeners(n) oder standardmäßig auf events.defaultMaxListenersfestgelegt ist.

function getMaxListeners(): number

Gibt zurück

Geerbt von Stream.getMaxListeners

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

Parameter

Gibt zurück

Geerbt von Stream.pipe

Standardmäßig druckt EventEmitters eine Warnung, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der emitter.setMaxListeners()-Methode kann der Grenzwert für diese spezifische EventEmitter Instanz geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function setMaxListeners(n: number): Readable

Parameter

Gibt zurück

Geerbt von Stream.setMaxListeners

Die Methode Symbol.for('nodejs.rejection') wird aufgerufen, wenn eine Versprechensablehnung beim Aussenden eines Ereignisses auftritt und captureRejections auf dem Emitter aktiviert ist. Es ist möglich, anstelle von events.captureRejectionSymbolzu verwendenSymbol.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

Geerbt von Stream.__@captureRejectionSymbol@175