Readable interface

Package:: @azure/storage-common

Extends: Stream

Propriétés

closed	C’est `true` après `'close'` avoir été émis.
destroyed	C’est `true` après `readable.destroy()` a été appelé.
errored	Retour d’erreur si le flux a été détruit avec une erreur.
readable	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'`.
readableAborted	Indique si le flux a été détruit ou a eu une erreur avant d’émettre `'end'`.
readableDidRead	Retourne si `'data'` cela a été émis.
readableEncoding	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 .
readableEnded	Devient `true` lorsque `'end'` l’événement est émis.
readableFlowing	Cette propriété reflète l’état actuel d’un `Readable` cours d’eau tel que décrit dans la section des Trois États .
readableHighWaterMark	Retourne la valeur de `highWaterMark` passé lors de la création de cette `Readable`.
readableLength	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`.
readableObjectMode	Getter pour la propriété `objectMode` d’un cours d’eau donné `Readable` .

Méthodes

addListener(string \| symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)	Alias de `emitter.on(eventName, listener)`.
compose(WritableStream \| WritableStream \| TransformStream \| (source: any) => void, Abortable)	`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. Si vous souhaitez plus d’informations, consultez `stream.compose(...streams)`.
destroy(Error)	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()`.
drop(number, Abortable)	Cette méthode renvoie un nouveau flux avec les premiers chunks de limite supprimés dès le départ.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé `eventName`, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux. Retourne `true` si l’événement avait des écouteurs, `false` sinon. import { EventEmitter } from 'node:events'; const myEmitter = new EventEmitter(); // First listener myEmitter.on('event', function firstListener() { console.log('Helloooo! first listener'); }); // Second listener myEmitter.on('event', function secondListener(arg1, arg2) { console.log(`event with parameters ${arg1}, ${arg2} in second listener`); }); // Third listener myEmitter.on('event', function thirdListener(...args) { const parameters = args.join(', '); console.log(`event with parameters ${parameters} in third listener`); }); console.log(myEmitter.listeners('event')); myEmitter.emit('event', 1, 2, 3, 4, 5); // Prints: // [ // [Function: firstListener], // [Function: secondListener], // [Function: thirdListener] // ] // Helloooo! first listener // event with parameters 1, 2 in second listener // event with parameters 1, 2, 3, 4, 5 in third listener
every((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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 `await`est 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`.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	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 `await`ed.
find((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)
find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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`.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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é.
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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 `await`ed. 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.
isPaused()	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`
iterator(ReadableIteratorOptions)	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.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	Retourne le nombre d’écouteurs à l’écoute de l’événement nommé `eventName`. Si `listener` est fourni, il retourne le nombre de fois où l’écouteur est trouvé dans la liste des écouteurs de l’événement.
listeners(string \| symbol)
listeners<E>(E)	Retourne une copie du tableau d’écouteurs pour l’événement nommé `eventName`. `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
map((data: any, options?: Abortable) => any, ReadableOperatorOptions)	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 `await`ed avant d’être transmise au flux de résultats.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Alias de `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	Ajoute la fonction `listener` à la fin du tableau d’écouteurs pour l’événement nommé `eventName`. Aucune vérification n’est effectuée pour voir si le `listener` a déjà été ajouté. Plusieurs appels passant la même combinaison de `eventName` et de `listener` entraînent l’ajout de la `listener` et l’appel, plusieurs fois. `server.on('connection', (stream) => { console.log('someone connected!'); });` Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés. Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode `emitter.prependListener()` peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => console.log('a')); myEE.prependListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
once(string \| symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)	Ajoute une fonction `listener` unique pour l’événement nommé `eventName`. La prochaine fois que `eventName` est déclenchée, cet écouteur est supprimé, puis appelé. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés. Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode `emitter.prependOnceListener()` peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.once('foo', () => console.log('a')); myEE.prependOnceListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
pause()	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'` .
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)	Ajoute la fonction `listener` au début du tableau d’écouteurs pour l’événement nommé `eventName`. Aucune vérification n’est effectuée pour voir si le `listener` a déjà été ajouté. Plusieurs appels passant la même combinaison de `eventName` et de `listener` entraînent l’ajout de la `listener` et l’appel, plusieurs fois. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Ajoute une fonction `listener` unique pour l’événement nommé `eventName` au début du tableau d’écouteurs. La prochaine fois que `eventName` est déclenchée, cet écouteur est supprimé, puis appelé. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Retourne une copie du tableau d’écouteurs pour l’événement nommé `eventName`, y compris les wrappers (tels que ceux créés par `.once()`). import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.once('log', () => console.log('log once')); // Returns a new Array with a function `onceWrapper` which has a property // `listener` which contains the original listener bound above const listeners = emitter.rawListeners('log'); const logFnWrapper = listeners[0]; // Logs "log once" to the console and does not unbind the `once` event logFnWrapper.listener(); // Logs "log once" to the console and removes the listener logFnWrapper(); emitter.on('log', () => console.log('log persistently')); // Will return a new Array with a single function bound by `.on()` above const newListeners = emitter.rawListeners('log'); // Logs "log persistently" twice newListeners[0](); emitter.emit('log');
read(number)	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.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	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.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Supprime tous les écouteurs, ou ceux de la `eventName`spécifiée. Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque l’instance de `EventEmitter` a été créée par un autre composant ou module (par exemple, des sockets ou des flux de fichiers). Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Supprime le `listener` spécifié du tableau d’écouteurs pour l’événement nommé `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le `eventName`spécifié, `removeListener()` doit être appelé plusieurs fois pour supprimer chaque instance. Une fois qu’un événement est émis, tous les écouteurs attachés à celui-ci au moment de l’émission sont appelés dans l’ordre. Cela implique que tout `removeListener()` appel `removeAllListeners()`après émission et avant la fin de l’exécution du dernier auditeur ne les `emit()` supprimera pas de la procédure en cours. Les événements suivants se comportent comme prévu. import { EventEmitter } from 'node:events'; class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); const callbackA = () => { console.log('A'); myEmitter.removeListener('event', callbackB); }; const callbackB = () => { console.log('B'); }; myEmitter.on('event', callbackA); myEmitter.on('event', callbackB); // callbackA removes listener callbackB but it will still be called. // Internal listener array at time of emit [callbackA, callbackB] myEmitter.emit('event'); // Prints: // A // B // callbackB is now removed. // Internal listener array [callbackA] myEmitter.emit('event'); // Prints: // A Comme les auditeurs sont gérés via un tableau interne, appeler cela modifie les indices de position de tout auditeur enregistré après la suppression de cet auditeur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la méthode `emitter.listeners()` devront être recréées. Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un événement unique (comme dans l’exemple ci-dessous), `removeListener()` supprime l’instance la plus récemment ajoutée. Dans l’exemple, l’écouteur `once('ping')` est supprimé : `import { EventEmitter } from 'node:events'; const ee = new EventEmitter(); function pong() { console.log('pong'); } ee.on('ping', pong); ee.once('ping', pong); ee.removeListener('ping', pong); ee.emit('ping'); ee.emit('ping');` Retourne une référence au `EventEmitter`, afin que les appels puissent être chaînés.
resume()	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'` .
setEncoding(BufferEncoding)	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); });`
some((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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 `await`ed 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`.
take(number, Abortable)	Cette méthode renvoie un nouveau flux avec les premiers chunks limites .
toArray(Abortable)	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.
unpipe(WritableStream)	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);`
unshift(any, BufferEncoding)	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.
wrap(ReadableStream)	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. });`
[asyncDispose]()	Appelle `readable.destroy()` avec un `AbortError` et retourne une promesse qui se tient à la fin du stream.
[asyncIterator]()
[toAsyncStreamable]()	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`.

Méthodes héritées

eventNames()	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) ]`
getMaxListeners()	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`.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Par défaut, `EventEmitter`s 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.
[captureRejectionSymbol](Error, string \| symbol, any[])	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. } }`

Détails de la propriété

closed

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

closed: boolean

Valeur de propriété

boolean

destroyed

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

destroyed: boolean

Valeur de propriété

boolean

errored

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

errored: Error | null

Valeur de propriété

Error | null

readable

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é

boolean

readableAborted

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

readableAborted: boolean

Valeur de propriété

boolean

readableDidRead

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

readableDidRead: boolean

Valeur de propriété

boolean

readableEncoding

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: BufferEncoding | null

Valeur de propriété

BufferEncoding | null

readableEnded

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

readableEnded: boolean

Valeur de propriété

boolean

readableFlowing

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: boolean | null

Valeur de propriété

boolean | null

readableHighWaterMark

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

readableHighWaterMark: number

Valeur de propriété

number

readableLength

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é

number

readableObjectMode

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

readableObjectMode: boolean

Valeur de propriété

boolean

Détails de la méthode

addListener(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

addListener<E>(E, (args: ReadableEventMap[E]) => void)

Alias de emitter.on(eventName, listener).

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

Paramètres

eventName: E

listener: (args: ReadableEventMap[E]) => void

Retours

this

compose(WritableStream | WritableStream | TransformStream | (source: any) => void, Abortable)

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.

Si vous souhaitez plus d’informations, consultez stream.compose(...streams).

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

Paramètres

stream: WritableStream | WritableStream | TransformStream | (source: any) => void

options: Abortable

Retours

Duplex

un courant composé du flux stream.

destroy(Error)

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): this

Paramètres

error: Error

Erreur qui sera transmise comme charge utile en 'error' cas d’événement

Retours

this

drop(number, Abortable)

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

limit: number

le nombre de morceaux à supprimer du lisible.

options: Abortable

Retours

Readable

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

emit(string | symbol, any[])

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

Paramètres

eventName: string | symbol

args: any[]

Retours

boolean

emit<E>(E, ReadableEventMap[E])

Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé eventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

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

Paramètres

eventName: E

args: ReadableEventMap[E]

Retours

boolean

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

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, "concurrency" | "signal">): Promise<boolean>

Paramètres

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

une fonction pour appeler chaque segment du flux. Asynchrone ou pas.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Promise<boolean>

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

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

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

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

une fonction pour filtrer les chunks du flux. Asynchrone ou pas.

options: ReadableOperatorOptions

Retours

Readable

un flux filtré par le prédicat fn.

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

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

Paramètres

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

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Promise<any>

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

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 is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>

Paramètres

fn: (data: any, options?: Abortable) => data is T

une fonction pour appeler chaque segment du flux. Asynchrone ou pas.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Promise<T | undefined>

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

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

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, "concurrency" | "signal">): Readable

Paramètres

fn: (data: any, options?: Abortable) => any

une fonction pour cartographier chaque segment du flux. Peut-être asynchrone. Ça peut être un jet ou un générateur.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Readable

un flux cartographié à plat avec la fonction fn.

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

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, "concurrency" | "signal">): Promise<void>

Paramètres

fn: (data: any, options?: Abortable) => void | Promise<void>

une fonction pour appeler chaque segment du flux. Asynchrone ou pas.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Promise<void>

une promesse pour la fin du stream.

isPaused()

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

boolean

iterator(ReadableIteratorOptions)

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>

Paramètres

options: ReadableIteratorOptions

Retours

AsyncIterator<any>

listenerCount(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

number

listenerCount<E>(E, (args: ReadableEventMap[E]) => void)

Retourne le nombre d’écouteurs à l’écoute de l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur est trouvé dans la liste des écouteurs de l’événement.

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

Paramètres

eventName: E

Nom de l’événement en cours d’écoute

listener: (args: ReadableEventMap[E]) => void

Fonction du gestionnaire d’événements

Retours

number

listeners(string | symbol)

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

Paramètres

eventName: string | symbol

Retours

(args: any[]) => void[]

listeners<E>(E)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

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

Paramètres

eventName: E

Retours

(args: ReadableEventMap[E]) => void[]

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

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

fn: (data: any, options?: Abortable) => any

une fonction pour cartographier chaque segment du flux. Asynchrone ou pas.

options: ReadableOperatorOptions

Retours

Readable

un flux cartographié avec la fonction fn.

off(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

off<E>(E, (args: ReadableEventMap[E]) => void)

Alias de emitter.removeListener().

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

Paramètres

eventName: E

listener: (args: ReadableEventMap[E]) => void

Retours

this

on(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

on<E>(E, (args: ReadableEventMap[E]) => void)

Ajoute la fonction listener à la fin du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si le listener a déjà été ajouté. Plusieurs appels passant la même combinaison de eventName et de listener entraînent l’ajout de la listener et l’appel, plusieurs fois.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Paramètres

eventName: E

Nom de l’événement.

listener: (args: ReadableEventMap[E]) => void

Fonction de rappel

Retours

this

once(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

once<E>(E, (args: ReadableEventMap[E]) => void)

Ajoute une fonction listener unique pour l’événement nommé eventName. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependOnceListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Paramètres

eventName: E

Nom de l’événement.

listener: (args: ReadableEventMap[E]) => void

Fonction de rappel

Retours

this

pause()

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(): this

Retours

this

prependListener(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

prependListener<E>(E, (args: ReadableEventMap[E]) => void)

Ajoute la fonction listener au début du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si le listener a déjà été ajouté. Plusieurs appels passant la même combinaison de eventName et de listener entraînent l’ajout de la listener et l’appel, plusieurs fois.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

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

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

Paramètres

eventName: E

Nom de l’événement.

listener: (args: ReadableEventMap[E]) => void

Fonction de rappel

Retours

this

prependOnceListener(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)

Ajoute une fonction listener unique pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

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

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

Paramètres

eventName: E

Nom de l’événement.

listener: (args: ReadableEventMap[E]) => void

Fonction de rappel

Retours

this

push(any, BufferEncoding)

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

Paramètres

chunk: any

encoding: BufferEncoding

Retours

boolean

rawListeners(string | symbol)

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

Paramètres

eventName: string | symbol

Retours

(args: any[]) => void[]

rawListeners<E>(E)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris les wrappers (tels que ceux créés par .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

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

Paramètres

eventName: E

Retours

(args: ReadableEventMap[E]) => void[]

read(number)

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

size: number

Argument optionnel pour spécifier la quantité de données à lire.

Retours

any

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

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

fn: (previous: any, data: any, options?: Abortable) => T

une fonction réductrice pour appeler chaque morceau du flux. Asynchrone ou pas.

Retours

Promise<T>

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

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

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

Paramètres

fn: (previous: T, data: any, options?: Abortable) => T

initial: T

options: Abortable

Retours

Promise<T>

removeAllListeners(string | symbol)

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

Paramètres

eventName: string | symbol

Retours

this

removeAllListeners<E>(E)

Supprime tous les écouteurs, ou ceux de la eventNamespécifiée.

Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque l’instance de EventEmitter a été créée par un autre composant ou module (par exemple, des sockets ou des flux de fichiers).

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

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

Paramètres

eventName: E

Retours

this

removeListener(string | symbol, (args: any[]) => void)

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

Paramètres

eventName: string | symbol

listener: (args: any[]) => void

Retours

this

removeListener<E>(E, (args: ReadableEventMap[E]) => void)

Supprime le listener spécifié du tableau d’écouteurs pour l’événement nommé eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le eventNamespécifié, removeListener() doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs attachés à celui-ci au moment de l’émission sont appelés dans l’ordre. Cela implique que tout removeListener() appel removeAllListeners()après émission et avant la fin de l’exécution du dernier auditeur ne les emit() supprimera pas de la procédure en cours. Les événements suivants se comportent comme prévu.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Comme les auditeurs sont gérés via un tableau interne, appeler cela modifie les indices de position de tout auditeur enregistré après la suppression de cet auditeur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la méthode emitter.listeners() devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un événement unique (comme dans l’exemple ci-dessous), removeListener() supprime l’instance la plus récemment ajoutée. Dans l’exemple, l’écouteur once('ping') est supprimé :

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

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

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

Paramètres

eventName: E

listener: (args: ReadableEventMap[E]) => void

Retours

this

resume()

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(): this

Retours

this

setEncoding(BufferEncoding)

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): this

Paramètres

encoding: BufferEncoding

Encodage à utiliser.

Retours

this

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

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, "concurrency" | "signal">): Promise<boolean>

Paramètres

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

une fonction pour appeler chaque segment du flux. Asynchrone ou pas.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Retours

Promise<boolean>

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

take(number, Abortable)

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

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

Paramètres

limit: number

le nombre de morceaux à prendre dans la lisible.

options: Abortable

Retours

Readable

un stream avec des chunks limites pris.

toArray(Abortable)

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

options: Abortable

Retours

Promise<any[]>

une promesse contenant un tableau contenant le contenu du flux.

unpipe(WritableStream)

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): this

Paramètres

destination: WritableStream

Flux spécifique optionnel à débrancher

Retours

this

unshift(any, BufferEncoding)

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

chunk: any

Un morceau de données à déverrouiller sur la file de lecture. Pour les flux ne fonctionnant pas en mode objet, chunk il doit y avoir une {string}, {Buffer}, {TypedArray}, {DataView} ou null. Pour les flux en mode objet, chunk cela peut être n’importe quelle valeur JavaScript.

encoding: BufferEncoding

Encodage des chunks de chaînes. Doit être un encodage valide Buffer , tel que 'utf8' ou 'ascii'.

wrap(ReadableStream)

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): this

Paramètres

stream: ReadableStream

Un flux « à l’ancienne » lisible

Retours

this

[asyncDispose]()

Appelle readable.destroy() avec un AbortError et retourne une promesse qui se tient à la fin du stream.

function [asyncDispose](): Promise<void>

Retours

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Retours

AsyncIterator<any>

AsyncIterator pour consommer pleinement le flux.

[toAsyncStreamable]()

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

ByteReadableStream

Détails de la méthode héritée

eventNames()

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

(string | symbol)[]

Hérité de Stream.eventsNames

getMaxListeners()

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

number

Hérité de Stream.getMaxAuditeurs

pipe<T>(T, PipeOptions)

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

Paramètres

destination: T

options: PipeOptions

Retours

Hérité de Stream.pipe

setMaxListeners(number)

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): this

Paramètres

n: number

Retours

this

Hérité de Stream.setMaxAuditeurs

[captureRejectionSymbol](Error, string | symbol, any[])

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

error: Error

event: string | symbol

args: any[]

Hérité de Stream. [captureSymboleRejet]