Readable class

new Readable(options?: ReadableOptions<Readable>)

Paramètres

C’est true après 'close' avoir été émis.

closed: boolean

Valeur de propriété

C’est true après readable.destroy() a été appelé.

destroyed: boolean

Valeur de propriété

Retour d’erreur si le flux a été détruit avec une erreur.

errored: null | Error

Valeur de propriété

Est true si il est sûr d’appeler « lu », ce qui signifie que le flux n’a pas été détruit ou émis 'error' ou 'end'.

readable: boolean

Valeur de propriété

Indique si le flux a été détruit ou a eu une erreur avant d’émettre 'end'.

readableAborted: boolean

Valeur de propriété

Retourne si 'data' cela a été émis.

readableDidRead: boolean

Valeur de propriété

Getter pour la propriété encoding d’un cours d’eau donné Readable . La encoding propriété peut être définie en utilisant la méthode setEncoding .

readableEncoding: null | BufferEncoding

Valeur de propriété

Devient true lorsque 'end' l’événement est émis.

readableEnded: boolean

Valeur de propriété

Cette propriété reflète l’état actuel d’un Readable cours d’eau tel que décrit dans la section des Trois États .

readableFlowing: null | boolean

Valeur de propriété

Retourne la valeur de highWaterMark passé lors de la création de cette Readable.

readableHighWaterMark: number

Valeur de propriété

Cette propriété contient le nombre d’octets (ou d’objets) dans la file d’attente prêts à être lus. La valeur fournit des données d’introspection concernant l’état du highWaterMark.

readableLength: number

Valeur de propriété

Getter pour la propriété objectMode d’un cours d’eau donné Readable .

readableObjectMode: boolean

Valeur de propriété

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

Paramètres

Retours

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

Paramètres

Retours

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) est équivalent à stream.compose(readable, s).

Cette méthode permet également de fournir un AbortSignal , qui détruira le flux composé en cas d’interruption.

Pour plus d’informations, consultez stream.compose(...streams).

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

Paramètres

Retours

un courant composé du flux stream.

Détruisez le flux. Émettez éventuellement un 'error' événement, et émettez un 'close' événement (sauf si emitClose est défini à false). Après cet appel, le flux lisible libérera toutes les ressources internes et les appels ultérieurs push() seront ignorés.

Une fois destroy() appelé, tout appel supplémentaire sera un no-op et aucune autre erreur sauf depuis _destroy() ne pourra être émise sous 'error'forme de .

Les implémentateurs ne doivent pas outrepasser cette méthode, mais plutôt implémenter readable._destroy().

function destroy(error?: Error): Readable

Paramètres

Retours

Cette méthode renvoie un nouveau flux avec les premiers chunks de limite supprimés dès le départ.

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

Paramètres

Retours

un stream avec des chunks limites abandonnés dès le départ.

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

Paramètres

Retours

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

Paramètres

Retours

Cette méthode est similaire à Array.prototype.every et appelle fn sur chaque segment du flux pour vérifier si toutes les valeurs de retour attendues sont des valeurs vérités pour fn. Une fois qu’un appel fn sur une valeur de retour ed chunk awaitest faux, le flux est détruit et la promesse est tenue avec false. Si tous les appels fn sur les chunks rendent une valeur vérité, la promesse est tenue avec true.

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

Paramètres

Retours

Une promesse évaluant si trueFN a rendu une valeur véritique pour chacun des chunks.

Cette méthode permet de filtrer le flux. Pour chaque chunk du flux, la fonction fn sera appelée et si elle retourne une valeur truthy, le chunk sera transmis au flux résultant. Si la fonction fn renvoie une promesse, cette promesse sera awaited.

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

Paramètres

Retours

un flux filtré par le prédicat fn.

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

Paramètres

Retours

Cette méthode est similaire à Array.prototype.find et appelle fn sur chaque chunk du flux pour trouver un chunk avec une valeur truthy pour fn. Une fois que la valeur de retour attendue d’un appel fn est véridique, le flux est détruit et la promesse est tenue avec une valeur pour laquelle fn a rendu une valeur truthy. Si tous les appels fn sur les chunks rendent une fausse valeur, la promesse est tenue avec undefined.

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

Paramètres

Retours

une promesse évaluant jusqu’au premier morceau pour lequel fn évaluait avec une valeur truthy, ou undefined si aucun élément n’était trouvé.

Cette méthode renvoie un nouveau flux en appliquant le callback donné à chaque segment du flux, puis en aplatissant le résultat.

Il est possible de retourner un flux ou un autre itérable ou asynchrone depuis fn et les flux résultants seront fusionnés (aplatis) dans le flux retourné.

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

Paramètres

Retours

un flux cartographié à plat avec la fonction fn.

Cette méthode permet d’itérer un flux. Pour chaque chunk du flux, la fonction fn sera appelée. Si la fonction fn renvoie une promesse, cette promesse sera awaited.

Cette méthode diffère des for await...of boucles en ce qu’elle peut éventuellement traiter les chunks simultanément. De plus, une forEach itération ne peut être arrêtée qu’en ayant passé une signal option et en annulant l’AbortController associé tandis qu’elle for await...of peut être arrêtée par break ou return. Dans tous les cas, le ruisseau sera détruit.

Cette méthode diffère de l’écoute de l’événement 'data' en ce qu’elle utilise l’événement readable dans la machinerie sous-jacente et peut limiter le nombre d’appels fn simultanés.

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

Paramètres

Retours

une promesse pour la fin du stream.

Une méthode utilitaire pour créer des flux lisibles à partir d’itérateurs.

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

Paramètres

Retours

Une méthode utilitaire pour créer un Readable à partir d’un web ReadableStream.

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

Paramètres

Retours

Retour que le flux ait été lu ou annulé.

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

Paramètres

Retours

La readable.isPaused() méthode retourne l’état de fonctionnement actuel du Readable. Celle-ci est principalement utilisée par le mécanisme qui sous-tend la readable.pipe() méthode. Dans la plupart des cas typiques, il n’y aura aucune raison d’utiliser cette méthode directement.

const readable = new stream.Readable();

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

function isPaused(): boolean

Retours

L’itérateur créé par cette méthode offre aux utilisateurs la possibilité d’annuler la destruction du flux si la for await...of boucle est quittée par return, break, ou throw, ou si l’itérateur doit détruire le flux si celui-ci a émis une erreur lors de l’itération.

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

Cette méthode permet de cartographier le flux. La fonction fn sera appelée pour chaque morceau du flux. Si la fonction fn retourne une promesse, cette promesse sera awaited avant d’être transmise au flux de résultats.

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

Paramètres

Retours

un flux cartographié avec la fonction fn.

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

Cette readable.pause() méthode fera qu’un flux en mode écoulement cessera d’émettre 'data' des événements, sortant ainsi du mode écoulement. Toute donnée disponible restera dans le tampon interne.

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

La readable.pause() méthode n’a aucun effet s’il y a un auditeur d’événement 'readable' .

function pause(): Readable

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

La readable.read() méthode lit les données du tampon interne et les renvoie. Si aucune donnée n’est disponible à la lecture, null est retournée. Par défaut, les données sont retournées sous forme d’objet Buffer sauf si un codage a été spécifié via la readable.setEncoding() méthode ou que le flux fonctionne en mode objet.

L’argument optionnel size spécifie un nombre précis d’octets à lire. Si size les octets ne sont pas disponibles pour la lecture, null ils seront retournés sauf si le flux est terminé, auquel cas toutes les données restantes dans le tampon interne seront retournées.

Si l’argument size n’est pas spécifié, toutes les données contenues dans le tampon interne seront renvoyées.

L’argument size doit être inférieur ou égal à 1 Gio.

La readable.read() méthode ne doit être appelée que sur Readable les flux fonctionnant en mode pause. En mode écoulement, readable.read() il est appelé automatiquement jusqu’à ce que le tampon interne soit complètement vidé.

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

Chaque appel à readable.read() retourne un morceau de données, ou null. Les chunks ne sont pas concaténés. Une while boucle est nécessaire pour consommer toutes les données actuellement dans le tampon. Lors de la lecture d’un fichier volumineux .read() , il peut retourner null, ayant consommé tout le contenu tamponné jusqu’à présent, mais il reste encore des données non tamponnées. Dans ce cas, un nouvel 'readable' événement sera émis lorsqu’il y aura plus de données dans le tampon. Enfin, l’événement 'end' sera émis lorsqu’il n’y aura plus de données à venir.

Par conséquent, pour lire l’intégralité du contenu d’un fichier à partir d’un readable, il est nécessaire de collecter des morceaux sur plusieurs 'readable' événements :

const chunks = [];

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

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

Un Readable flux en mode objet retournera toujours un seul élément d’un appel vers readable.read(size), quelle que soit la valeur de l’argument size .

Si la readable.read() méthode renvoie un bloc de données, un 'data' événement sera également émis.

Appeler lu après l’émission de l’événement 'end' reviendra null. Aucune erreur d’exécution ne sera affichée.

function read(size?: number): any

Paramètres

Retours

Cette méthode appelle fn sur chaque segment du flux dans l’ordre, lui transmettant le résultat du calcul sur l’élément précédent. Il restitue une promesse de la valeur finale de la réduction.

Si aucune valeur initiale n’est fournie, le premier segment du flux est utilisé comme valeur initiale. Si le flux est vide, la promesse est rejetée par un TypeError avec la ERR_INVALID_ARGS propriété de code.

La fonction réductrice itère le flux élément par élément, ce qui signifie qu’il n’y a ni paramètre de concurrence ni parallélisme. Pour effectuer une réduction simultanée, vous pouvez extraire la fonction asynchrone vers readable.map la méthode.

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

Paramètres

Retours

une promesse de la valeur finale de la réduction.

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

La readable.resume() méthode fait qu’un flux explicitement Readable mis en pause reprend l’émission 'data' d’événements, basculant le flux en mode écoulement.

La readable.resume() méthode peut être utilisée pour consommer entièrement les données d’un flux sans réellement traiter ces données :

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

La readable.resume() méthode n’a aucun effet s’il y a un auditeur d’événement 'readable' .

function resume(): Readable

Retours

La readable.setEncoding() méthode définit le codage des caractères pour les données lues dans le Readable flux.

Par défaut, aucun encodage n’est assigné et les données du flux seront retournées sous forme Buffer d’objets. Définir un encodage fait que les données du flux sont retournées sous forme de chaînes de l’encodage spécifié plutôt que sous forme Buffer d’objets. Par exemple, l’appel readable.setEncoding('utf8') fait que les données de sortie sont interprétées comme des données UTF-8, et transmises sous forme de chaînes. Appeler readable.setEncoding('hex') fera en sorte que les données soient encodées au format chaîne hexadécimal.

Le Readable flux gère correctement les caractères multi-octets délivrés via le flux qui seraient autrement mal décodés s’ils étaient simplement extraits du flux sous forme Buffer d’objets.

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

Paramètres

Retours

Cette méthode est similaire à Array.prototype.some et appelle fn sur chaque chunk du flux jusqu’à ce que la valeur de retour attendue soit true (ou toute valeur truthy). Une fois qu’un appel FN sur une valeur de retour de chunks awaited est vrai, le flux est détruit et la promesse est tenue avec true. Si aucun des fn n’appelle les chunks ne rend une valeur vérité, la promesse est tenue avec false.

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

Paramètres

Retours

Une promesse évaluant si trueFN a restitué une valeur de vérité pour au moins un des chunks.

Cette méthode renvoie un nouveau flux avec les premiers chunks limites .

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

Paramètres

Retours

un stream avec des chunks limites pris.

Cette méthode permet d’obtenir facilement le contenu d’un flux.

Comme cette méthode lit l’intégralité du flux en mémoire, elle annule les avantages des flux. Il est conçu pour l’interopérabilité et la commodité, pas comme le principal moyen de consommer les flux.

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

Paramètres

Retours

une promesse contenant un tableau contenant le contenu du flux.

Une méthode utilitaire pour créer un web ReadableStream à partir d’un Readablefichier .

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

Paramètres

Retours

La readable.unpipe() méthode détache un Writable flux précédemment attaché en utilisant la méthode du tuyau .

Si le n’est destination pas spécifié, alors tous les tuyaux sont détachés.

Si le destination est spécifié, mais qu’aucun tuyau n’est configuré pour cela, alors la méthode ne fait rien.

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

Paramètres

Retours

Passant chunk comme null signalant la fin du flux (EOF) et se comporte de la même manière que readable.push(null), après quoi aucune autre donnée ne peut être écrite. Le signal EOF est placé à l’extrémité du tampon et toutes les données mises en mémoire tampon seront toujours vidées.

La readable.unshift() méthode renvoie un morceau de données dans le tampon interne. Cela est utile dans certaines situations où un flux est consommé par du code qui doit « déconsommer » une certaine quantité de données qu’il a extraites de manière optimiste de la source, afin que ces données puissent être transmises à une autre partie.

La stream.unshift(chunk) méthode ne peut pas être appelée après l’émission de l’événement 'end' ou une erreur d’exécution sera lancée.

Les développeurs qui utilisent stream.unshift() souvent devraient envisager de passer à un Transform flux à la place. Voir la API for stream implementers section pour plus d’informations.

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

Contrairement au push, il stream.unshift(chunk) ne met pas fin au processus de lecture en réinitialisant l’état interne de lecture du flux. Cela peut entraîner des résultats inattendus si readable.unshift() elle est appelée lors d’une lecture (c’est-à-dire depuis une implémentation _read sur un flux personnalisé). Suivre l’appel avec readable.unshift() un push immédiat réinitialisera correctement l’état de lecture, cependant il est préférable d’éviter d’appeler readable.unshift() pendant la lecture.

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

Paramètres

Avant Node.js 0.10, les flux n’implémentaient pas l’API complète node:stream du module telle qu’elle est actuellement définie. (Voir Compatibility pour plus d’informations.)

Lorsqu’on utilise une ancienne bibliothèque de Node.js qui émet 'data' des événements et possède une méthode de pause uniquement consultative, cette readable.wrap() méthode peut être utilisée pour créer un Readable flux qui utilise l’ancien flux comme source de données.

Il sera rarement nécessaire de l’utiliser readable.wrap() , mais cette méthode a été proposée pour faciliter l’interaction avec les anciennes applications et bibliothèques Node.js.

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

Paramètres

Retours

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

Retours

AsyncIterator pour consommer pleinement le flux.

Lorsque le --experimental-stream-iter drapeau est activé, Readable les flux implémentent le Stream.toAsyncStreamable protocole, permettant une consommation efficace par l’API stream/iter .

Cela fournit un itérateur asynchrone batché qui draine le tampon interne du flux en Uint8Array[] batches, amortissant la surcharge Promise par bloc du chemin standard Symbol.asyncIterator . Pour les flux en mode octet, les chunks sont directement obtenus sous forme Buffer d’instances (qui sont des Uint8Array sous-classes). Pour les flux en mode objet ou encodés, chaque bloc est normalisé à Uint8Array avant le batching.

L’itérateur retourné est identifié comme source validée, donc from() le transmet sans normalisation supplémentaire.

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'

Sans le drapeau --experimental-stream-iter , appeler cette méthode obtient ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Retours

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs.

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

Retours

Hérité de Stream.eventsNames

Retourne la valeur maximale actuelle de l’écouteur pour l'EventEmitter qui est définie par emitter.setMaxListeners(n) ou par défaut sur events.defaultMaxListeners.

function getMaxListeners(): number

Retours

Hérité de Stream.getMaxAuditeurs

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

Paramètres

Retours

Hérité de Stream.pipe

Par défaut, EventEmitters affiche un avertissement si plus de 10 écouteurs sont ajoutés pour un événement particulier. Il s’agit d’une valeur par défaut utile qui permet de trouver des fuites de mémoire. La méthode emitter.setMaxListeners() permet de modifier la limite pour cette instance de EventEmitter spécifique. La valeur peut être définie sur Infinity (ou 0) pour indiquer un nombre illimité d’écouteurs.

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function setMaxListeners(n: number): Readable

Paramètres

Retours

Hérité de Stream.setMaxAuditeurs

La Symbol.for('nodejs.rejection') méthode est appelée au cas où un rejet de promesse survient lors de l’émission d’un événement et captureRejections est activée sur l’émetteur. Il est possible d’utiliser events.captureRejectionSymbol à la place de 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[])

Paramètres

Hérité de Stream.__@captureRejectionSymbol@180