Readable class

new Readable(options?: ReadableOptions<Readable>)

Parameters

Is true nadat 'close' er is uitgezonden.

closed: boolean

Waarde van eigenschap

Is true nadat readable.destroy() er is opgeroepen.

destroyed: boolean

Waarde van eigenschap

Geeft een foutmelding terug als de stroom is vernietigd met een foutmelding.

errored: null | Error

Waarde van eigenschap

Is true als het veilig is om 'read' aan te roepen, wat betekent dat de stream niet is vernietigd of uitgezonden 'error' of 'end'.

readable: boolean

Waarde van eigenschap

Geeft terug of de stroom werd vernietigd of foutief was voordat hij uitzendde 'end'.

readableAborted: boolean

Waarde van eigenschap

Geeft terug of 'data' er is uitgezonden.

readableDidRead: boolean

Waarde van eigenschap

Getter voor de eigenschap encoding van een gegeven Readable stroom. De encoding eigenschap kan worden ingesteld met behulp van de setEncoding-methode .

readableEncoding: null | BufferEncoding

Waarde van eigenschap

Wordt wanneer true'end' een gebeurtenis wordt uitgezonden.

readableEnded: boolean

Waarde van eigenschap

Deze eigenschap weerspiegelt de huidige staat van een Readable beek, zoals beschreven in de sectie Drie toestanden .

readableFlowing: null | boolean

Waarde van eigenschap

Geeft de waarde van highWaterMark door gegeven terug bij het creëren van dit Readable.

readableHighWaterMark: number

Waarde van eigenschap

Deze eigenschap bevat het aantal bytes (of objecten) in de wachtrij dat klaar is om gelezen te worden. De waarde levert introspectiegegevens over de status van de highWaterMark.

readableLength: number

Waarde van eigenschap

Getter voor de eigenschap objectMode van een gegeven Readable stroom.

readableObjectMode: boolean

Waarde van eigenschap

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

Parameters

Retouren

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

Parameters

Retouren

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

Deze methode maakt het ook mogelijk om een AbortSignal te leveren, die de gecomponeerde stroom vernietigt wanneer deze wordt afgebroken.

Zie stream.compose(...streams) voor meer informatie.

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

Parameters

Retouren

een stroom die samengesteld is met de stroom stream.

Vernietig de stroom. Optioneel emitteren een 'error' event en een 'close' event (tenzij emitClose is ingesteld op false). Na deze aanroep zal de leesbare stream alle interne bronnen vrijgeven en worden daaropvolgende aanroepen push() genegeerd.

Zodra destroy() deze is aangeroepen, zijn eventuele verdere aanroepen een no-op en mogen er geen verdere fouten behalve van _destroy() worden uitgegeven als 'error'.

Implementatoren moeten deze methode niet overschrijven, maar in plaats daarvan implementeren readable._destroy().

function destroy(error?: Error): Readable

Parameters

Retouren

Deze methode geeft een nieuwe stream terug waarbij de eerste limietchunks vanaf het begin zijn weggelaten.

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

Parameters

Retouren

Een stream met limietstukken die vanaf het begin zijn afgevallen.

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

Parameters

Retouren

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

Parameters

Retouren

Deze methode lijkt op Array.prototype.every en roept fn aan op elk chunk in de stream om te controleren of alle gewachte retourwaarden de truthy-waarden voor fn zijn. Zodra een fn call op een chunk awaited return value vals is, wordt de stream vernietigd en wordt de belofte nagekomen met false. Als alle fn-aanroepen op de chunks een truthy-waarde teruggeven, wordt de belofte vervuld met true.

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

Parameters

Retouren

Een belofte die evalueert of trueFN een waarheidswaarde teruggeeft voor elk van de chunks.

Deze methode maakt het filteren van de stroom mogelijk. Voor elk chunk in de stroom wordt de fn-functie aangeroepen en als deze een truthy-waarde teruggeeft, wordt de chunk doorgegeven aan de resultaatstroom. Als de fn-functie een belofte teruggeeft, zal die belofte ed zijn await.

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

Parameters

Retouren

een stroom gefilterd met het predicaat FN.

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

Parameters

Retouren

Deze methode lijkt op Array.prototype.find en roept fn aan op elk chunk in de stream om een chunk te vinden met een truthy-waarde voor fn. Zodra de verwachte retourwaarde van een fn-oproep waarheidsgetrouwe is, wordt de stroom vernietigd en wordt de belofte nagekomen met een waarde waarvoor fn een waarheidswaarde terugstuurde. Als alle fn-aanroepen op de chunks een valse waarde teruggeven, wordt de belofte nagekomen met undefined.

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

Parameters

Retouren

een belofte die evalueert naar het eerste stuk waarvoor Fn met een truthy-waarde evalueerde, of undefined als er geen element is gevonden.

Deze methode geeft een nieuwe stroom terug door de gegeven callback toe te passen op elk stuk van de stroom en vervolgens het resultaat af te vlakken.

Het is mogelijk om een stroom of een andere iterabele of asynchrone iterable terug te geven vanuit fn en de resulterende stromen worden samengevoegd (afgevlakt) in de teruggestuurde stroom.

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

Parameters

Retouren

een stroom die wordt platgemapt met de functie fn.

Deze methode maakt het mogelijk om een stroom te itereren. Voor elk chunk in de stroom wordt de fn-functie aangeroepen. Als de fn-functie een belofte teruggeeft, zal die belofte ed zijn await.

Deze methode verschilt van for await...of lussen doordat het optioneel chunks gelijktijdig kan verwerken. Daarnaast kan een forEach iteratie alleen worden gestopt door een signal optie te hebben gepasseerd en de bijbehorende AbortController te beëindigen terwijl for await...of kan worden gestopt met break of return. In beide gevallen wordt de stroom vernietigd.

Deze methode verschilt van het luisteren naar het 'data' evenement doordat het het evenement in de onderliggende machine gebruikt readable en het aantal gelijktijdige fn-aanroepen kan beperken.

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

Parameters

Retouren

Een belofte voor wanneer de stream is afgelopen.

Een hulpmethode om leesbare stromen te maken uit iterators.

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

Parameters

Retouren

Een hulpmethode om een Readable te maken vanuit een web ReadableStream.

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

Parameters

Retouren

Komt terug of de stream is gelezen of geannuleerd.

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

Parameters

Retouren

De readable.isPaused() methode geeft de huidige bedrijfstoestand van de Readableterug. Dit wordt voornamelijk gebruikt door het mechanisme dat ten grondslag ligt aan de readable.pipe() methode. In de meeste typische gevallen is er geen reden om deze methode direct te gebruiken.

const readable = new stream.Readable();

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

function isPaused(): boolean

Retouren

De iterator die met deze methode wordt gemaakt, geeft gebruikers de optie om de vernietiging van de stroom te annuleren als de for await...of lus wordt verlaten door return, break, of throw, of als de iterator de stroom moet vernietigen als de stroom tijdens iteratie een fout veroorzaakt.

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

Deze methode maakt het mogelijk om de stroom in kaart te brengen. De fn-functie wordt aangeroepen voor elk chunk in de stroom. Als de fn-functie een belofte teruggeeft - zal die belofte ed zijn awaitvoordat deze aan de resultaatstroom wordt doorgegeven.

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

Parameters

Retouren

Een stroom die is gemapt met de functie FN.

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

De readable.pause() methode zorgt ervoor dat een stroom in stromende modus stopt met het uitzenden 'data' van gebeurtenissen, waardoor deze uit de stromende modus schakelt. Alle beschikbare data blijft in de interne buffer.

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

De readable.pause() methode heeft geen effect als er een 'readable' event listener is.

function pause(): Readable

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

De readable.read() methode leest gegevens uit de interne buffer en geeft deze terug. Als er geen gegevens beschikbaar zijn om te lezen, null wordt deze teruggegeven. Standaard wordt de data als object Buffer teruggegeven, tenzij er een codering is gespecificeerd met de readable.setEncoding() methode of de stream in objectmodus werkt.

Het optionele size argument specificeert een specifiek aantal bytes om te lezen. Als size bytes niet beschikbaar zijn om gelezen te worden, null worden ze teruggegeven tenzij de stroom is beëindigd, in welk geval alle gegevens die nog in de interne buffer zitten worden teruggegeven.

Als het size argument niet wordt gespecificeerd, worden alle gegevens in de interne buffer teruggegeven.

Het size argument moet kleiner zijn dan of gelijk aan 1 GiB.

De readable.read() methode mag alleen worden aangeroepen op Readable stromen die in gepauzeerde modus werken. In flowing mode readable.read() wordt automatisch aangeroepen totdat de interne buffer volledig is leeggezogen.

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

Elke oproep naar readable.read() geeft een stuk data terug, of null. De stukken zijn niet samengevoegd. Een while lus is noodzakelijk om alle data die momenteel in de buffer aanwezig is te consumeren. Bij het lezen van een groot bestand .read() kan het terugkomen nulldat alle tot nu toe gebufferde inhoud is verbruikt, maar er is nog meer data te komen die nog niet gebufft is. In dit geval wordt er een nieuw 'readable' event gegenereerd wanneer er meer data in de buffer is. Ten slotte wordt het 'end' evenement uitgezonden wanneer er geen data meer beschikbaar is.

Daarom is het nodig om de volledige inhoud van een bestand uit een readablete lezen, om stukken over meerdere 'readable' gebeurtenissen te verzamelen:

const chunks = [];

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

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

Een Readable stroom in objectmodus zal altijd één item teruggeven van een aanroep naar readable.read(size), ongeacht de waarde van het size argument.

Als de readable.read() methode een stuk data teruggeeft, wordt er ook een 'data' gebeurtenis uitgezonden.

Call-read nadat het 'end' event is uitgezonden, zal terugkerennull. Er zal geen runtime-fout worden geactiveerd.

function read(size?: number): any

Parameters

Retouren

Deze methode roept fn aan op elk stuk van de stroom in volgorde, waarbij het resultaat van de berekening op het vorige element wordt doorgegeven. Het geeft een belofte terug voor de uiteindelijke waarde van de reductie.

Als er geen beginwaarde wordt aangegeven, wordt het eerste stuk van de stroom als beginwaarde gebruikt. Als de stroom leeg is, wordt de belofte afgewezen met een TypeError met de ERR_INVALID_ARGS code-eigenschap.

De reducerfunctie herhaalt de stroom element voor element, wat betekent dat er geen gelijktijdige parameter of parallelisme is. Om gelijktijdig een reduce uit te voeren, kun je de asynchrone functie naar readable.map methode extraheren.

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

Parameters

Retouren

een belofte voor de uiteindelijke waarde van de reductie.

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

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

Parameters

Retouren

De readable.resume() methode zorgt ervoor dat een expliciet gepauzeerde Readable stroom weer gebeurtenissen uitzendt 'data' , waardoor de stroom in stromende modus wordt overgeschakeld.

De readable.resume() methode kan worden gebruikt om de data van een stroom volledig te consumeren zonder daadwerkelijk iets van die data te verwerken:

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

De readable.resume() methode heeft geen effect als er een 'readable' event listener is.

function resume(): Readable

Retouren

De readable.setEncoding() methode stelt de tekencodering in voor data die uit de Readable stroom wordt gelezen.

Standaard wordt er geen codering toegewezen en worden stroomgegevens als Buffer objecten teruggegeven. Het instellen van een codering zorgt ervoor dat de stroomgegevens worden teruggegeven als strings van de gespecificeerde codering in plaats van als Buffer objecten. Bijvoorbeeld, het aanroepen readable.setEncoding('utf8') zorgt ervoor dat de uitvoerdata wordt geïnterpreteerd als UTF-8-data en als strings wordt doorgegeven. Callen readable.setEncoding('hex') zorgt ervoor dat de data in hexadecimale stringformaat wordt gecodeerd.

De Readable stroom zal multi-byte karakters correct afhandelen die via de stroom worden geleverd en anders verkeerd gedecodeerd zouden worden als ze simpelweg als Buffer objecten uit de stroom worden gehaald.

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

Parameters

Retouren

Deze methode lijkt op Array.prototype.some en roept fn aan op elk chunk in de stream totdat de gewachte returnwaarde (of een willekeurige truthy-waarde) is true . Zodra een fn call op een chunk awaited return value waarheidsgetrouwe is, wordt de stream vernietigd en wordt de belofte nagekomen met true. Als geen van de fn-oproepen op de chunks een waarheidsgetrouwe waarde teruggeeft, wordt de belofte nagekomen met false.

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

Parameters

Retouren

Een belofte die evalueert of trueFN een truthy-waarde teruggeeft voor ten minste één van de chunks.

Deze methode geeft een nieuwe stroom terug met de eerste limietchunks .

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

Parameters

Retouren

Een stream met limietstukken genomen.

Deze methode maakt het gemakkelijk mogelijk om de inhoud van een stroom te verkrijgen.

Omdat deze methode de hele stroom in het geheugen leest, worden de voordelen van stromen tenietgedaan. Het is bedoeld voor interoperabiliteit en gemak, niet als de primaire manier om streams te consumeren.

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

Parameters

Retouren

een belofte met een array met de inhoud van de stream.

Een hulpmethode om een web ReadableStream te creëren uit een Readable.

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

Parameters

Retouren

De readable.unpipe() methode maakt een Writable eerder aangesloten stroom los met behulp van de pijpmethode .

Als de niet destination wordt gespecificeerd, worden alle leidingen losgekoppeld.

Als de is destination gespecificeerd, maar er is geen pijp voor ingesteld, dan doet de methode niets.

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

Parameters

Retouren

Als signaal het einde van de stroom (EOF) doorgeven chunknull en gedraagt zich hetzelfde als readable.push(null), waarna geen gegevens meer kunnen worden geschreven. Het EOF-signaal wordt aan het einde van de buffer geplaatst en alle gebufferde data wordt nog steeds verwijderd.

De readable.unshift() methode duwt een stuk data terug in de interne buffer. Dit is nuttig in bepaalde situaties waarin een stream wordt verbruikt door code die een bepaalde hoeveelheid data moet "on-consumeren" die hij optimistisch uit de bron heeft gehaald, zodat de data aan een andere partij kan worden doorgegeven.

De stream.unshift(chunk) methode kan niet worden aangeroepen nadat het 'end' event is verzonden, anders wordt er een runtime-fout gegooid.

Ontwikkelaars die vaak gebruiken stream.unshift() , zouden moeten overwegen om over te stappen op het gebruik van een Transform stream. Zie de API for stream implementers sectie voor meer informatie.

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

In tegenstelling tot pushstream.unshift(chunk) zal het leesproces niet worden beëindigd door de interne leestoestand van de stream te resetten. Dit kan onverwachte resultaten veroorzaken als readable.unshift() deze wordt aangeroepen tijdens een read (bijvoorbeeld vanuit een _read implementatie op een aangepaste stream). Door de call direct readable.unshift()te volgen reset je de leestoestand correct, maar het is het beste om het oproepen readable.unshift() tijdens het lezen te vermijden.

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

Parameters

Voor Node.js 0.10 implementeerden streams niet de volledige node:stream module API zoals die nu is gedefinieerd. (Zie Compatibility voor meer informatie.)

Wanneer je een oudere Node.js bibliotheek gebruikt die gebeurtenissen genereert 'data' en een pauzemethode heeft die alleen adviserend is, kan deze readable.wrap() methode worden gebruikt om een Readable stroom te creëren die de oude stroom als databron gebruikt.

Het zal zelden nodig zijn om te gebruiken readable.wrap() , maar de methode is geboden als een gemak voor interactie met oudere Node.js applicaties en bibliotheken.

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

Parameters

Retouren

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

Retouren

AsyncIterator om de stroom volledig te consumeren.

Wanneer de --experimental-stream-iter vlag is ingeschakeld, Readable implementeren streams het Stream.toAsyncStreamable protocol, waardoor efficiënt gebruik door de stream/iter API mogelijk wordt.

Dit levert een batchgesynchroniseerde asynchrone iterator die de interne buffer van de stream in Uint8Array[] batches afvoert, waarbij de per-chunk Promise-overhead van het standaardpad Symbol.asyncIterator wordt geamortiseerd. Voor byte-mode streams worden chunks direct als Buffer instanties opgeleverd (die subklassen zijn Uint8Array ). Voor objectmodus- of gecodeerde stromen wordt elk chunk genormaliseerd naar Uint8Array vóór batching.

De teruggestuurde iterator wordt getagd als een gevalideerde bron, zodat from() deze zonder extra normalisatie doorgaat.

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'

Zonder de --experimental-stream-iter vlag gooit ERR_STREAM_ITER_MISSING_FLAGhet aanroepen van deze methode .

function [toAsyncStreamable](): ByteReadableStream

Retouren

Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd.

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

Retouren

Geërfd van Stream.eventNames

Retourneert de huidige maximum-listenerwaarde voor de EventEmitter die is ingesteld door emitter.setMaxListeners(n) of standaard ingesteld op events.defaultMaxListeners.

function getMaxListeners(): number

Retouren

Geërfd van Stream.getMaxListeners

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

Parameters

Retouren

Geërfd van Stream.pipe

Standaard worden EventEmitters een waarschuwing afgedrukt als er meer dan 10 listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode emitter.setMaxListeners() kan de limiet voor dit specifieke EventEmitter exemplaar worden gewijzigd. De waarde kan worden ingesteld op Infinity (of 0) om een onbeperkt aantal listeners aan te geven.

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

function setMaxListeners(n: number): Readable

Parameters

Retouren

Geërfd van Stream.setMaxListeners

De Symbol.for('nodejs.rejection') methode wordt aangeroepen voor het geval een belofteafwijzing plaatsvindt bij het uitzenden van een gebeurtenis en captureRejections wordt ingeschakeld op de emitter. Het is mogelijk om in plaats van events.captureRejectionSymbolte gebruikenSymbol.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[])

Parameters

Geërfd van Stream.__@captureRejectionSymbol@180