Readable interface

Pakket:: @azure/storage-common

Uitbreiding: Stream

Eigenschappen

closed	Is `true` nadat `'close'` er is uitgezonden.
destroyed	Is `true` nadat `readable.destroy()` er is opgeroepen.
errored	Geeft een foutmelding terug als de stroom is vernietigd met een foutmelding.
readable	Is `true` als het veilig is om 'read' aan te roepen, wat betekent dat de stream niet is vernietigd of uitgezonden `'error'` of `'end'`.
readableAborted	Geeft terug of de stroom werd vernietigd of foutief was voordat hij uitzendde `'end'`.
readableDidRead	Geeft terug of `'data'` er is uitgezonden.
readableEncoding	Getter voor de eigenschap `encoding` van een gegeven `Readable` stroom. De `encoding` eigenschap kan worden ingesteld met behulp van de setEncoding-methode .
readableEnded	Wordt wanneer `true'end'` een gebeurtenis wordt uitgezonden.
readableFlowing	Deze eigenschap weerspiegelt de huidige staat van een `Readable` beek, zoals beschreven in de sectie Drie toestanden .
readableHighWaterMark	Geeft de waarde van `highWaterMark` door gegeven terug bij het creëren van dit `Readable`.
readableLength	Deze eigenschap bevat het aantal bytes (of objecten) in de wachtrij dat klaar is om gelezen te worden. De waarde levert introspectiegegevens over de status van de `highWaterMark`.
readableObjectMode	Getter voor de eigenschap `objectMode` van een gegeven `Readable` stroom.

Methoden

addListener(string \| symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)	Alias voor `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)` is gelijk aan `stream.compose(readable, s)`. Deze methode maakt het ook mogelijk om een `AbortSignal` te leveren, die de gecomponeerde stroom vernietigt wanneer deze wordt afgebroken. Zie `stream.compose(...streams)` voor meer informatie.
destroy(Error)	Vernietig de stroom. Optioneel emitteren een `'error'` event en een `'close'` event (tenzij `emitClose` is ingesteld op `false`). Na deze aanroep zal de leesbare stream alle interne bronnen vrijgeven en worden daaropvolgende aanroepen `push()` genegeerd. Zodra `destroy()` deze is aangeroepen, zijn eventuele verdere aanroepen een no-op en mogen er geen verdere fouten behalve van `_destroy()` worden uitgegeven als `'error'`. Implementatoren moeten deze methode niet overschrijven, maar in plaats daarvan implementeren `readable._destroy()`.
drop(number, Abortable)	Deze methode geeft een nieuwe stream terug waarbij de eerste limietchunks vanaf het begin zijn weggelaten.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam `eventName`, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven. Retourneert `true` als de gebeurtenis listeners had, anders `false`. 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">)	Deze methode lijkt op `Array.prototype.every` en roept fn aan op elk chunk in de stream om te controleren of alle gewachte retourwaarden de truthy-waarden voor fn zijn. Zodra een fn call op een chunk `await`ed return value vals is, wordt de stream vernietigd en wordt de belofte nagekomen met `false`. Als alle fn-aanroepen op de chunks een truthy-waarde teruggeven, wordt de belofte vervuld met `true`.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	Deze methode maakt het filteren van de stroom mogelijk. Voor elk chunk in de stroom wordt de fn-functie aangeroepen en als deze een truthy-waarde teruggeeft, wordt de chunk doorgegeven aan de resultaatstroom. Als de fn-functie een belofte teruggeeft, zal die belofte ed zijn `await`.
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">)	Deze methode lijkt op `Array.prototype.find` en roept fn aan op elk chunk in de stream om een chunk te vinden met een truthy-waarde voor fn. Zodra de verwachte retourwaarde van een fn-oproep waarheidsgetrouwe is, wordt de stroom vernietigd en wordt de belofte nagekomen met een waarde waarvoor fn een waarheidswaarde terugstuurde. Als alle fn-aanroepen op de chunks een valse waarde teruggeven, wordt de belofte nagekomen met `undefined`.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Deze methode geeft een nieuwe stroom terug door de gegeven callback toe te passen op elk stuk van de stroom en vervolgens het resultaat af te vlakken. Het is mogelijk om een stroom of een andere iterabele of asynchrone iterable terug te geven vanuit fn en de resulterende stromen worden samengevoegd (afgevlakt) in de teruggestuurde stroom.
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Deze methode maakt het mogelijk om een stroom te itereren. Voor elk chunk in de stroom wordt de fn-functie aangeroepen. Als de fn-functie een belofte teruggeeft, zal die belofte ed zijn `await`. Deze methode verschilt van `for await...of` lussen doordat het optioneel chunks gelijktijdig kan verwerken. Daarnaast kan een `forEach` iteratie alleen worden gestopt door een `signal` optie te hebben gepasseerd en de bijbehorende AbortController te beëindigen terwijl `for await...of` kan worden gestopt met `break` of `return`. In beide gevallen wordt de stroom vernietigd. Deze methode verschilt van het luisteren naar het `'data'` evenement doordat het het evenement in de onderliggende machine gebruikt `readable` en het aantal gelijktijdige fn-aanroepen kan beperken.
isPaused()	De `readable.isPaused()` methode geeft de huidige bedrijfstoestand van de `Readable`terug. Dit wordt voornamelijk gebruikt door het mechanisme dat ten grondslag ligt aan de `readable.pipe()` methode. In de meeste typische gevallen is er geen reden om deze methode direct te gebruiken. `const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false`
iterator(ReadableIteratorOptions)	De iterator die met deze methode wordt gemaakt, geeft gebruikers de optie om de vernietiging van de stroom te annuleren als de `for await...of` lus wordt verlaten door `return`, `break`, of `throw`, of als de iterator de stroom moet vernietigen als de stroom tijdens iteratie een fout veroorzaakt.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam `eventName`. Als `listener` wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.
listeners(string \| symbol)
listeners<E>(E)	Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam `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)	Deze methode maakt het mogelijk om de stroom in kaart te brengen. De fn-functie wordt aangeroepen voor elk chunk in de stroom. Als de fn-functie een belofte teruggeeft - zal die belofte ed zijn `await`voordat deze aan de resultaatstroom wordt doorgegeven.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Alias voor `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	Hiermee voegt u de functie `listener` toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam `eventName`. Er worden geen controles uitgevoerd om te zien of de `listener` al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van `eventName` doorgeven en `listener` leiden ertoe dat de `listener` meerdere keren wordt toegevoegd en aangeroepen. `server.on('connection', (stream) => { console.log('someone connected!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld. Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode `emitter.prependListener()` kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix. `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)	Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat `eventName` wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld. Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode `emitter.prependOnceListener()` kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix. `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()	De `readable.pause()` methode zorgt ervoor dat een stroom in stromende modus stopt met het uitzenden `'data'` van gebeurtenissen, waardoor deze uit de stromende modus schakelt. Alle beschikbare data blijft in de interne buffer. const readable = getReadableStreamSomehow(); readable.on('data', (chunk) => { console.log(`Received ${chunk.length} bytes of data.`); readable.pause(); console.log('There will be no additional data for 1 second.'); setTimeout(() => { console.log('Now data will start flowing again.'); readable.resume(); }, 1000); }); De `readable.pause()` methode heeft geen effect als er een `'readable'` event listener is.
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)	Hiermee voegt u de functie `listener` toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam `eventName`. Er worden geen controles uitgevoerd om te zien of de `listener` al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van `eventName` doorgeven en `listener` leiden ertoe dat de `listener` meerdere keren wordt toegevoegd en aangeroepen. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Hiermee voegt u een eenmalige`listener` functie toe voor de gebeurtenis met de naam `eventName` aan de die begint van de listenersmatrix. De volgende keer dat `eventName` wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam `eventName`, inclusief eventuele wrappers (zoals die zijn gemaakt door `.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)	De `readable.read()` methode leest gegevens uit de interne buffer en geeft deze terug. Als er geen gegevens beschikbaar zijn om te lezen, `null` wordt deze teruggegeven. Standaard wordt de data als object `Buffer` teruggegeven, tenzij er een codering is gespecificeerd met de `readable.setEncoding()` methode of de stream in objectmodus werkt. Het optionele `size` argument specificeert een specifiek aantal bytes om te lezen. Als `size` bytes niet beschikbaar zijn om gelezen te worden, `null` worden ze teruggegeven tenzij de stroom is beëindigd, in welk geval alle gegevens die nog in de interne buffer zitten worden teruggegeven. Als het `size` argument niet wordt gespecificeerd, worden alle gegevens in de interne buffer teruggegeven. Het `size` argument moet kleiner zijn dan of gelijk aan 1 GiB. De `readable.read()` methode mag alleen worden aangeroepen op `Readable` stromen die in gepauzeerde modus werken. In flowing mode `readable.read()` wordt automatisch aangeroepen totdat de interne buffer volledig is leeggezogen. const readable = getReadableStreamSomehow(); // 'readable' may be triggered multiple times as data is buffered in readable.on('readable', () => { let chunk; console.log('Stream is readable (new data received in buffer)'); // Use a loop to make sure we read all currently available data while (null !== (chunk = readable.read())) { console.log(`Read ${chunk.length} bytes of data...`); } }); // 'end' will be triggered once when there is no more data available readable.on('end', () => { console.log('Reached end of stream.'); }); Elke oproep naar `readable.read()` geeft een stuk data terug, of `null`. De stukken zijn niet samengevoegd. Een `while` lus is noodzakelijk om alle data die momenteel in de buffer aanwezig is te consumeren. Bij het lezen van een groot bestand `.read()` kan het terugkomen `null`dat alle tot nu toe gebufferde inhoud is verbruikt, maar er is nog meer data te komen die nog niet gebufft is. In dit geval wordt er een nieuw `'readable'` event gegenereerd wanneer er meer data in de buffer is. Ten slotte wordt het `'end'` evenement uitgezonden wanneer er geen data meer beschikbaar is. Daarom is het nodig om de volledige inhoud van een bestand uit een `readable`te lezen, om stukken over meerdere `'readable'` gebeurtenissen te verzamelen: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` Een `Readable` stroom in objectmodus zal altijd één item teruggeven van een aanroep naar `readable.read(size)`, ongeacht de waarde van het `size` argument. Als de `readable.read()` methode een stuk data teruggeeft, wordt er ook een `'data'` gebeurtenis uitgezonden. Call-read nadat het `'end'` event is uitgezonden, zal terugkeren`null`. Er zal geen runtime-fout worden geactiveerd.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	Deze methode roept fn aan op elk stuk van de stroom in volgorde, waarbij het resultaat van de berekening op het vorige element wordt doorgegeven. Het geeft een belofte terug voor de uiteindelijke waarde van de reductie. Als er geen beginwaarde wordt aangegeven, wordt het eerste stuk van de stroom als beginwaarde gebruikt. Als de stroom leeg is, wordt de belofte afgewezen met een `TypeError` met de `ERR_INVALID_ARGS` code-eigenschap. De reducerfunctie herhaalt de stroom element voor element, wat betekent dat er geen gelijktijdige parameter of parallelisme is. Om gelijktijdig een reduce uit te voeren, kun je de asynchrone functie naar `readable.map` methode extraheren.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Hiermee verwijdert u alle listeners of de listeners van de opgegeven `eventName`. Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het `EventEmitter` exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen). Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Hiermee verwijdert u de opgegeven `listener` uit de listenermatrix voor de gebeurtenis met de naam `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven `eventName`, moet `removeListener()` meerdere keren worden aangeroepen om elk exemplaar te verwijderen. Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat elke of `removeListener()` call `removeAllListeners()`na het uitzenden en voordat de laatste luisteraar de uitvoering voltooit, ze niet uit `emit()` de uitvoering zullen verwijderen. Volgende gebeurtenissen gedragen zich zoals verwacht. 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 Omdat luisteraars worden beheerd via een interne array, zal het aanroepen hiervan de positie-indexen veranderen van elke luisteraar die na verwijdering van de luisteraar is geregistreerd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode `emitter.listeners()` opnieuw moeten worden gemaakt. Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert `removeListener()` het laatst toegevoegde exemplaar. In het voorbeeld wordt de `once('ping')` listener verwijderd: `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');` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
resume()	De `readable.resume()` methode zorgt ervoor dat een expliciet gepauzeerde `Readable` stroom weer gebeurtenissen uitzendt `'data'` , waardoor de stroom in stromende modus wordt overgeschakeld. De `readable.resume()` methode kan worden gebruikt om de data van een stroom volledig te consumeren zonder daadwerkelijk iets van die data te verwerken: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` De `readable.resume()` methode heeft geen effect als er een `'readable'` event listener is.
setEncoding(BufferEncoding)	De `readable.setEncoding()` methode stelt de tekencodering in voor data die uit de `Readable` stroom wordt gelezen. Standaard wordt er geen codering toegewezen en worden stroomgegevens als `Buffer` objecten teruggegeven. Het instellen van een codering zorgt ervoor dat de stroomgegevens worden teruggegeven als strings van de gespecificeerde codering in plaats van als `Buffer` objecten. Bijvoorbeeld, het aanroepen `readable.setEncoding('utf8')` zorgt ervoor dat de uitvoerdata wordt geïnterpreteerd als UTF-8-data en als strings wordt doorgegeven. Callen `readable.setEncoding('hex')` zorgt ervoor dat de data in hexadecimale stringformaat wordt gecodeerd. De `Readable` stroom zal multi-byte karakters correct afhandelen die via de stroom worden geleverd en anders verkeerd gedecodeerd zouden worden als ze simpelweg als `Buffer` objecten uit de stroom worden gehaald. `const readable = getReadableStreamSomehow(); readable.setEncoding('utf8'); readable.on('data', (chunk) => { assert.equal(typeof chunk, 'string'); console.log('Got %d characters of string data:', chunk.length); });`
some((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Deze methode lijkt op `Array.prototype.some` en roept fn aan op elk chunk in de stream totdat de gewachte returnwaarde (of een willekeurige truthy-waarde) is `true` . Zodra een fn call op een chunk `await`ed return value waarheidsgetrouwe is, wordt de stream vernietigd en wordt de belofte nagekomen met `true`. Als geen van de fn-oproepen op de chunks een waarheidsgetrouwe waarde teruggeeft, wordt de belofte nagekomen met `false`.
take(number, Abortable)	Deze methode geeft een nieuwe stroom terug met de eerste limietchunks .
toArray(Abortable)	Deze methode maakt het gemakkelijk mogelijk om de inhoud van een stroom te verkrijgen. Omdat deze methode de hele stroom in het geheugen leest, worden de voordelen van stromen tenietgedaan. Het is bedoeld voor interoperabiliteit en gemak, niet als de primaire manier om streams te consumeren.
unpipe(WritableStream)	De `readable.unpipe()` methode maakt een `Writable` eerder aangesloten stroom los met behulp van de pijpmethode . Als de niet `destination` wordt gespecificeerd, worden alle leidingen losgekoppeld. Als de is `destination` gespecificeerd, maar er is geen pijp voor ingesteld, dan doet de methode niets. `import fs from 'node:fs'; const readable = getReadableStreamSomehow(); const writable = fs.createWriteStream('file.txt'); // All the data from readable goes into 'file.txt', // but only for the first second. readable.pipe(writable); setTimeout(() => { console.log('Stop writing to file.txt.'); readable.unpipe(writable); console.log('Manually close the file stream.'); writable.end(); }, 1000);`
unshift(any, BufferEncoding)	Als signaal het einde van de stroom (EOF) doorgeven `chunknull` en gedraagt zich hetzelfde als `readable.push(null)`, waarna geen gegevens meer kunnen worden geschreven. Het EOF-signaal wordt aan het einde van de buffer geplaatst en alle gebufferde data wordt nog steeds verwijderd. De `readable.unshift()` methode duwt een stuk data terug in de interne buffer. Dit is nuttig in bepaalde situaties waarin een stream wordt verbruikt door code die een bepaalde hoeveelheid data moet "on-consumeren" die hij optimistisch uit de bron heeft gehaald, zodat de data aan een andere partij kan worden doorgegeven. De `stream.unshift(chunk)` methode kan niet worden aangeroepen nadat het `'end'` event is verzonden, anders wordt er een runtime-fout gegooid. Ontwikkelaars die vaak gebruiken `stream.unshift()` , zouden moeten overwegen om over te stappen op het gebruik van een `Transform` stream. Zie de `API for stream implementers` sectie voor meer informatie. // Pull off a header delimited by \n\n. // Use unshift() if we get too much. // Call the callback with (error, header, stream). import { StringDecoder } from 'node:string_decoder'; function parseHeader(stream, callback) { stream.on('error', callback); stream.on('readable', onReadable); const decoder = new StringDecoder('utf8'); let header = ''; function onReadable() { let chunk; while (null !== (chunk = stream.read())) { const str = decoder.write(chunk); if (str.includes('\n\n')) { // Found the header boundary. const split = str.split(/\n\n/); header += split.shift(); const remaining = split.join('\n\n'); const buf = Buffer.from(remaining, 'utf8'); stream.removeListener('error', callback); // Remove the 'readable' listener before unshifting. stream.removeListener('readable', onReadable); if (buf.length) stream.unshift(buf); // Now the body of the message can be read from the stream. callback(null, header, stream); return; } // Still reading the header. header += str; } } } In tegenstelling tot push`stream.unshift(chunk)` zal het leesproces niet worden beëindigd door de interne leestoestand van de stream te resetten. Dit kan onverwachte resultaten veroorzaken als `readable.unshift()` deze wordt aangeroepen tijdens een read (bijvoorbeeld vanuit een _read implementatie op een aangepaste stream). Door de call direct `readable.unshift()`te volgen reset je de leestoestand correct, maar het is het beste om het oproepen `readable.unshift()` tijdens het lezen te vermijden.
wrap(ReadableStream)	Voor Node.js 0.10 implementeerden streams niet de volledige `node:stream` module API zoals die nu is gedefinieerd. (Zie `Compatibility` voor meer informatie.) Wanneer je een oudere Node.js bibliotheek gebruikt die gebeurtenissen genereert `'data'` en een pauzemethode heeft die alleen adviserend is, kan deze `readable.wrap()` methode worden gebruikt om een `Readable` stroom te creëren die de oude stroom als databron gebruikt. Het zal zelden nodig zijn om te gebruiken `readable.wrap()` , maar de methode is geboden als een gemak voor interactie met oudere Node.js applicaties en bibliotheken. `import { OldReader } from './old-api-module.js'; import { Readable } from 'node:stream'; const oreader = new OldReader(); const myReader = new Readable().wrap(oreader); myReader.on('readable', () => { myReader.read(); // etc. });`
[asyncDispose]()	Belt met een `AbortError` en `readable.destroy()` geeft een belofte terug die wordt nagekomen wanneer de stream is afgerond.
[asyncIterator]()
[toAsyncStreamable]()	Wanneer de `--experimental-stream-iter` vlag is ingeschakeld, `Readable` implementeren streams het `Stream.toAsyncStreamable` protocol, waardoor efficiënt gebruik door de `stream/iter` API mogelijk wordt. Dit levert een batchgesynchroniseerde asynchrone iterator die de interne buffer van de stream in `Uint8Array[]` batches afvoert, waarbij de per-chunk Promise-overhead van het standaardpad `Symbol.asyncIterator` wordt geamortiseerd. Voor byte-mode streams worden chunks direct als `Buffer` instanties opgeleverd (die subklassen zijn `Uint8Array` ). Voor objectmodus- of gecodeerde stromen wordt elk chunk genormaliseerd naar `Uint8Array` vóór batching. De teruggestuurde iterator wordt getagd als een gevalideerde bron, zodat `from()` deze zonder extra normalisatie doorgaat. `import { Readable } from 'node:stream'; import { text, from } from 'node:stream/iter'; const readable = new Readable({ read() { this.push('hello'); this.push(null); }, }); // Readable is automatically consumed via toAsyncStreamable console.log(await text(from(readable))); // 'hello'` Zonder de `--experimental-stream-iter` vlag gooit `ERR_STREAM_ITER_MISSING_FLAG`het aanroepen van deze methode .

Overgenomen methoden

eventNames()	Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]`
getMaxListeners()	Retourneert de huidige maximum-listenerwaarde voor de `EventEmitter` die is ingesteld door `emitter.setMaxListeners(n)` of standaard ingesteld op `events.defaultMaxListeners`.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Standaard worden `EventEmitter`s een waarschuwing afgedrukt als er meer dan `10` listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode `emitter.setMaxListeners()` kan de limiet voor dit specifieke `EventEmitter` exemplaar worden gewijzigd. De waarde kan worden ingesteld op `Infinity` (of `0`) om een onbeperkt aantal listeners aan te geven. Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
[captureRejectionSymbol](Error, string \| symbol, any[])	De `Symbol.for('nodejs.rejection')` methode wordt aangeroepen voor het geval een belofteafwijzing plaatsvindt bij het uitzenden van een gebeurtenis en `captureRejections` wordt ingeschakeld op de emitter. Het is mogelijk om in plaats van `events.captureRejectionSymbol`te gebruiken`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. } }`

Eigenschapdetails

closed

Is true nadat 'close' er is uitgezonden.

closed: boolean

Waarde van eigenschap

boolean

destroyed

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

destroyed: boolean

Waarde van eigenschap

boolean

errored

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

errored: Error | null

Waarde van eigenschap

Error | null

readable

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

readable: boolean

Waarde van eigenschap

boolean

readableAborted

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

readableAborted: boolean

Waarde van eigenschap

boolean

readableDidRead

Geeft terug of 'data' er is uitgezonden.

readableDidRead: boolean

Waarde van eigenschap

boolean

readableEncoding

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

readableEncoding: BufferEncoding | null

Waarde van eigenschap

BufferEncoding | null

readableEnded

Wordt wanneer true'end' een gebeurtenis wordt uitgezonden.

readableEnded: boolean

Waarde van eigenschap

boolean

readableFlowing

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

readableFlowing: boolean | null

Waarde van eigenschap

boolean | null

readableHighWaterMark

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

readableHighWaterMark: number

Waarde van eigenschap

number

readableLength

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

readableLength: number

Waarde van eigenschap

number

readableObjectMode

Getter voor de eigenschap objectMode van een gegeven Readable stroom.

readableObjectMode: boolean

Waarde van eigenschap

boolean

Methodedetails

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Alias voor emitter.on(eventName, listener).

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

Parameters

eventName: E

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

Retouren

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

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

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

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

Parameters

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

options: Abortable

Retouren

Duplex

een stroom die samengesteld is met de stroom stream.

destroy(Error)

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

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

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

function destroy(error?: Error): this

Parameters

error: Error

Fout die als payload wordt doorgegeven in het 'error' geval

Retouren

this

drop(number, Abortable)

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

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

Parameters

limit: number

het aantal stukken dat uit de leesbare categorie moet verdwijnen.

options: Abortable

Retouren

Readable

Een stream met limietstukken die vanaf het begin zijn afgevallen.

emit(string | symbol, any[])

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

Parameters

eventName: string | symbol

args: any[]

Retouren

boolean

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

Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam eventName, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, anders false.

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

Parameters

eventName: E

args: ReadableEventMap[E]

Retouren

boolean

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

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

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

Parameters

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

een functie om elk stuk van de stroom aan te roepen. Asynchroon of niet.

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

Retouren

Promise<boolean>

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

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

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

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

Parameters

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

een functie om chunks uit de stream te filteren. Asynchroon of niet.

options: ReadableOperatorOptions

Retouren

Readable

een stroom gefilterd met het predicaat 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>

Parameters

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

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

Retouren

Promise<any>

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

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

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

Parameters

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

een functie om elk stuk van de stroom aan te roepen. Asynchroon of niet.

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

Retouren

Promise<T | undefined>

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

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

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

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

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

Parameters

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

een functie om elk chunk in de stream te mappen. Misschien is het asynchroon. Misschien een stroom of generator.

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

Retouren

Readable

een stroom die wordt platgemapt met de functie fn.

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

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

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

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

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

Parameters

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

een functie om elk stuk van de stroom aan te roepen. Asynchroon of niet.

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

Retouren

Promise<void>

Een belofte voor wanneer de stream is afgelopen.

isPaused()

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

const readable = new stream.Readable();

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

function isPaused(): boolean

Retouren

boolean

iterator(ReadableIteratorOptions)

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

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

Parameters

options: ReadableIteratorOptions

Retouren

AsyncIterator<any>

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

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

Parameters

eventName: string | symbol

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

Retouren

number

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

Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam eventName. Als listener wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.

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

Parameters

eventName: E

De naam van de gebeurtenis die wordt geluisterd

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

De functie gebeurtenis-handler

Retouren

number

listeners(string | symbol)

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

Parameters

eventName: string | symbol

Retouren

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

listeners<E>(E)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam 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[]

Parameters

eventName: E

Retouren

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

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

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

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

Parameters

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

een functie om elk chunk in de stream te mappen. Asynchroon of niet.

options: ReadableOperatorOptions

Retouren

Readable

Een stroom die is gemapt met de functie FN.

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Alias voor emitter.removeListener().

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

Parameters

eventName: E

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

Retouren

this

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Hiermee voegt u de functie listener toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

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

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName: E

De naam van de gebeurtenis.

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

De callback-functie

Retouren

this

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

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

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependOnceListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName: E

De naam van de gebeurtenis.

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

De callback-functie

Retouren

this

pause()

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

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

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

function pause(): this

Retouren

this

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Hiermee voegt u de functie listener toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

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

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

Parameters

eventName: E

De naam van de gebeurtenis.

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

De callback-functie

Retouren

this

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Hiermee voegt u een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName aan de die begint van de listenersmatrix. De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

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

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

Parameters

eventName: E

De naam van de gebeurtenis.

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

De callback-functie

Retouren

this

push(any, BufferEncoding)

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

Parameters

chunk: any

encoding: BufferEncoding

Retouren

boolean

rawListeners(string | symbol)

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

Parameters

eventName: string | symbol

Retouren

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

rawListeners<E>(E)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName, inclusief eventuele wrappers (zoals die zijn gemaakt door .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[]

Parameters

eventName: E

Retouren

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

read(number)

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

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

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

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

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

const readable = getReadableStreamSomehow();

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

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

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

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

const chunks = [];

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

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

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

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

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

function read(size?: number): any

Parameters

size: number

Optioneel argument om aan te geven hoeveel data gelezen moet worden.

Retouren

any

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

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

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

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

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

Parameters

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

een reducerfunctie om elk chunk in de stroom aan te roepen. Asynchroon of niet.

Retouren

Promise<T>

een belofte voor de uiteindelijke waarde van de reductie.

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>

Parameters

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

initial: T

options: Abortable

Retouren

Promise<T>

removeAllListeners(string | symbol)

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

Parameters

eventName: string | symbol

Retouren

this

removeAllListeners<E>(E)

Hiermee verwijdert u alle listeners of de listeners van de opgegeven eventName.

Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het EventEmitter exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen).

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

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

Parameters

eventName: E

Retouren

this

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

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

Parameters

eventName: string | symbol

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

Retouren

this

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

Hiermee verwijdert u de opgegeven listener uit de listenermatrix voor de gebeurtenis met de naam eventName.

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

removeListener() verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven eventName, moet removeListener() meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat elke of removeListener() call removeAllListeners()na het uitzenden en voordat de laatste luisteraar de uitvoering voltooit, ze niet uit emit() de uitvoering zullen verwijderen. Volgende gebeurtenissen gedragen zich zoals verwacht.

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

Omdat luisteraars worden beheerd via een interne array, zal het aanroepen hiervan de positie-indexen veranderen van elke luisteraar die na verwijdering van de luisteraar is geregistreerd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode emitter.listeners() opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert removeListener() het laatst toegevoegde exemplaar. In het voorbeeld wordt de once('ping') listener verwijderd:

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

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

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

Parameters

eventName: E

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

Retouren

this

resume()

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

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

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

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

function resume(): this

Retouren

this

setEncoding(BufferEncoding)

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

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

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

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

function setEncoding(encoding: BufferEncoding): this

Parameters

encoding: BufferEncoding

De codering die moet worden gebruikt.

Retouren

this

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

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

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

Parameters

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

een functie om elk stuk van de stroom aan te roepen. Asynchroon of niet.

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

Retouren

Promise<boolean>

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

take(number, Abortable)

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

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

Parameters

limit: number

Het aantal stukken dat uit het leesbare materiaal moet worden gehaald.

options: Abortable

Retouren

Readable

Een stream met limietstukken genomen.

toArray(Abortable)

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

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

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

Parameters

options: Abortable

Retouren

Promise<any[]>

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

unpipe(WritableStream)

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

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

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

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

function unpipe(destination?: WritableStream): this

Parameters

destination: WritableStream

Optionele specifieke stroom om uit te voeren

Retouren

this

unshift(any, BufferEncoding)

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

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

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

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

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

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

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

Parameters

chunk: any

Een stuk data om terug te schakelen naar de leeswachtrij. Voor streams die niet in objectmodus werken, chunk moet het een {string}, {Buffer}, {TypedArray}, {DataView} of null. Voor objectmodusstromen chunk kan elke JavaScript-waarde zijn.

encoding: BufferEncoding

Codering van string-chunks. Moet een geldige Buffer codering zijn, zoals 'utf8' of 'ascii'.

wrap(ReadableStream)

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

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

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

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

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

function wrap(stream: ReadableStream): this

Parameters

stream: ReadableStream

Een "old style" leesbare stream

Retouren

this

[asyncDispose]()

Belt met een AbortError en readable.destroy() geeft een belofte terug die wordt nagekomen wanneer de stream is afgerond.

function [asyncDispose](): Promise<void>

Retouren

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Retouren

AsyncIterator<any>

AsyncIterator om de stroom volledig te consumeren.

[toAsyncStreamable]()

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

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

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

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

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

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

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

function [toAsyncStreamable](): ByteReadableStream

Retouren

ByteReadableStream

Details overgenomen methode

eventNames()

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

import { EventEmitter } from 'node:events';

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

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

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

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

Retouren

(string | symbol)[]

Geërfd van Stream.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Retouren

number

Geërfd van Stream.getMaxListeners

pipe<T>(T, PipeOptions)

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

Parameters

destination: T

options: PipeOptions

Retouren

Geërfd van Stream.pipe

setMaxListeners(number)

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

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

function setMaxListeners(n: number): this

Parameters

n: number

Retouren

this

Geërfd van Stream.setMaxListeners

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

De Symbol.for('nodejs.rejection') methode wordt aangeroepen voor het geval een belofteafwijzing plaatsvindt bij het uitzenden van een gebeurtenis en captureRejections wordt ingeschakeld op de emitter. Het is mogelijk om in plaats van events.captureRejectionSymbolte gebruikenSymbol.for('nodejs.rejection').

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

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

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

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

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

Parameters

error: Error

event: string | symbol

args: any[]

Geërfd van Stream. [captureReweianceSymbool]