Readable interface

Paket:: @azure/storage-common

Extends: Stream

Eigenschaften

closed	Es ist `true` danach `'close'` ausgestrahlt worden.
destroyed	Es ist `true` danach `readable.destroy()` aufgerufen worden.
errored	Gibt einen Fehler zurück, wenn der Strom mit einem Fehler zerstört wurde.
readable	Ist `true` , wenn es sicher ist, gelesen zu rufen, was bedeutet, dass der Strom nicht zerstört oder ausgesandt `'error'` wurde oder `'end'`.
readableAborted	Gibt zurück, ob der Strom vor der Aussendung `'end'`zerstört oder fehlerhaft war.
readableDidRead	Es wird bestätigt, ob `'data'` ausgesandt wurde.
readableEncoding	Getter für die Eigenschaft `encoding` eines gegebenen `Readable` Stroms. Die Eigenschaft `encoding` kann mit der setEncoding-Methode gesetzt werden.
readableEnded	Es wird zu `true` dem Zeitpunkt, in dem `'end'` ein Ereignis ausgestrahlt wird.
readableFlowing	Diese Eigenschaft spiegelt den aktuellen Zustand eines `Readable` Baches wider, wie im Abschnitt " Drei Zustände " beschrieben.
readableHighWaterMark	Gibt beim Erstellen dieses zurück `highWaterMark`den Wert von `Readable` gegeben.
readableLength	Diese Eigenschaft enthält die Anzahl der Bytes (oder Objekte) in der Warteschlange, die zum Lesen bereit sind. Der Wert liefert Introspektionsdaten zum Status der `highWaterMark`.
readableObjectMode	Getter für die Eigenschaft `objectMode` eines gegebenen `Readable` Stroms.

Methoden

addListener(string \| symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)	Alias für `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)` entspricht `stream.compose(readable, s)`. Mit diesem Verfahren kann auch ein bereitgestellt werden `AbortSignal` , was den komponierten Strom beim Abbruch zerstört. Weitere Informationen finden Sie unter `stream.compose(...streams)`.
destroy(Error)	Zerstören Sie den Strom. Optional kann ein `'error'` Event ausgesendet werden, und ein `'close'` Event ausgesendet werden (sofern `emitClose` nicht auf gesetzt ist `false`). Nach diesem Aufruf gibt der lesbare Stream alle internen Ressourcen frei und nachfolgende Aufrufe `push()` werden ignoriert. Sobald `destroy()` aufgerufen wurde, werden weitere Anrufe ein no-op und keine weiteren Fehler außer von `_destroy()` können als `'error'`ausgesendet werden. Implementatoren sollten diese Methode nicht überschreiben, sondern stattdessen implementieren `readable._destroy()`.
drop(number, Abortable)	Diese Methode liefert einen neuen Stream zurück, bei dem die ersten Limit-Chunks von Anfang an weggelassen wurden.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen `eventName`registriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis. Gibt `true` zurück, wenn das Ereignis Listener hatte, `false` andernfalls. 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">)	Diese Methode ähnelt und `Array.prototype.every` ruft fn auf jedem Chunk im Strom auf, um zu prüfen, ob alle wartenden Rückgabewerte wahrheitswürdige Werte für fn sind. Sobald ein fn-Call auf einem Chunked-Rückgabewert `await`falsch ist, wird der Strom zerstört und das Versprechen mit `false`erfüllt. Wenn alle fn-Aufrufe auf den Chunks einen wahrheitswerten Wert zurückgeben, wird das Versprechen mit `true`erfüllt.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	Diese Methode ermöglicht das Filtern des Stroms. Für jeden Chunk im Strom wird die fn-Funktion aufgerufen, und wenn sie einen truthy-Wert zurückgibt, wird der Chunk an den Ergebnisstrom weitergegeben. Wenn die fn-Funktion ein Versprechen zurückgibt – dann ist `await`dieses Versprechen 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">)	Diese Methode ähnelt und `Array.prototype.find` ruft auf jedem Chunk im Stream fn auf, um einen Chunk mit einem Truthy-Wert für fn zu finden. Sobald der erwartete Rückgabewert eines Fn-Calls Truthy ist, wird der Stream zerstört und das Versprechen mit einem Wert erfüllt, für den Fn einen Truthy-Wert zurückgegeben hat. Wenn alle fn-Aufrufe auf den Chunks einen falschen Wert zurückgeben, wird das Versprechen mit `undefined`erfüllt.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Diese Methode gibt einen neuen Stream zurück, indem der gegebene Callback auf jeden Block des Streams angewendet und das Ergebnis abgeflacht wird. Es ist möglich, einen Strom oder einen anderen iterablen oder asynchronen Iterablen von fn zurückzugeben, und die resultierenden Ströme werden in den zurückgesendeten Strom eingegliedert (abgeflacht).
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Diese Methode ermöglicht das Iterieren eines Stroms. Für jeden Chunk im Strom wird die fn-Funktion aufgerufen. Wenn die fn-Funktion ein Versprechen zurückgibt – dann ist `await`dieses Versprechen ed. Diese Methode unterscheidet sich von `for await...of` Schleifen dadurch, dass sie optional Chunks gleichzeitig verarbeiten kann. Außerdem kann eine `forEach` Iteration nur gestoppt werden, indem eine `signal` Option bestanden und der zugehörige AbortController abgebrochen wird, während `for await...of` mit oder `break`gestoppt `return` werden kann. In beiden Fällen wird der Strom zerstört. Diese Methode unterscheidet sich vom Abhören des Ereignisses `'data'` dadurch, dass sie das `readable` Ereignis in der zugrunde liegenden Maschine verwendet und die Anzahl gleichzeitiger FN-Aufrufe begrenzen kann.
isPaused()	Die Methode `readable.isPaused()` liefert den aktuellen Betriebszustand der `Readable`. Dies wird hauptsächlich vom Mechanismus genutzt, der der Methode `readable.pipe()` zugrunde liegt. In den meisten typischen Fällen gibt es keinen Grund, diese Methode direkt anzuwenden. `const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false`
iterator(ReadableIteratorOptions)	Der durch diese Methode erstellte Iterator gibt den Nutzern die Möglichkeit, die Zerstörung des Stroms abzubrechen, wenn die Schleife `for await...of` von `return`, `break`, oder `throw`, beendet wird, oder wenn der Iterator den Strom zerstören sollte, wenn der Strom während der Iteration einen Fehler ausstrahlt.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen `eventName`lauschen. Wenn `listener` angegeben wird, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.
listeners(string \| symbol)
listeners<E>(E)	Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen `eventName`zurück. `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
map((data: any, options?: Abortable) => any, ReadableOperatorOptions)	Diese Methode erlaubt die Abbildung des Stroms. Die fn-Funktion wird für jeden Chunk im Strom aufgerufen. Wenn die fn-Funktion ein Versprechen zurückgibt, wird dieses Versprechen ed sein `await`, bevor es an den Ergebnisstrom weitergegeben wird.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Alias für `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	Fügt die `listener`-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen `eventName`hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die `listener` bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus `eventName` übergeben, und `listener` führen dazu, dass die `listener` mehrmals hinzugefügt und aufgerufen wird. `server.on('connection', (stream) => { console.log('someone connected!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können. Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die `emitter.prependListener()`-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden. `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)	Fügt eine einmalige`listener`-Funktion für das Ereignis mit dem Namen `eventName`hinzu. Wenn `eventName` das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können. Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die `emitter.prependOnceListener()`-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden. `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()	Die Methode `readable.pause()` bewirkt, dass ein Strom im Fließmodus aufhört, Ereignisse auszusenden `'data'` , und aus dem Fließmodus wechselt. Alle verfügbaren Daten bleiben im internen Puffer. const readable = getReadableStreamSomehow(); readable.on('data', (chunk) => { console.log(`Received ${chunk.length} bytes of data.`); readable.pause(); console.log('There will be no additional data for 1 second.'); setTimeout(() => { console.log('Now data will start flowing again.'); readable.resume(); }, 1000); }); Die Methode `readable.pause()` hat keine Wirkung, wenn es einen `'readable'` Ereignis-Listener gibt.
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)	Fügt die `listener`-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen `eventName`hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die `listener` bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus `eventName` übergeben, und `listener` führen dazu, dass die `listener` mehrmals hinzugefügt und aufgerufen wird. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Fügt dem beginnenden des Listenersarrays eine `listenereventName` Funktion für das Ereignis hinzu, das genannt wird. Wenn `eventName` das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen `eventName`zurück, einschließlich aller Wrapper (z. B. von `.once()`erstellt). 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)	Die Methode `readable.read()` liest Daten aus dem internen Puffer und gibt sie zurück. Wenn keine Daten zum Lesen verfügbar sind, `null` wird sie zurückgegeben. Standardmäßig werden die Daten als `Buffer` Objekt zurückgegeben, es sei denn, eine Codierung wurde mit der Methode `readable.setEncoding()` angegeben oder der Strom arbeitet im Objektmodus. Das optionale `size` Argument gibt eine bestimmte Anzahl von Bytes an, die gelesen werden sollen. Wenn `size` keine Bytes zum Lesen verfügbar sind, `null` werden sie zurückgegeben, es sei denn , der Strom ist beendet, in diesem Fall werden alle im internen Puffer verbleibenden Daten zurückgegeben. Wenn das Argument `size` nicht angegeben ist, werden alle im internen Puffer enthaltenen Daten zurückgegeben. Das Argument `size` muss kleiner als oder gleich 1 GiB sein. Die Methode `readable.read()` sollte nur bei `Readable` Strömen aufgerufen werden, die im Pause-Modus arbeiten. Im Fließmodus wird automatisch aufgerufen, `readable.read()` bis der interne Puffer vollständig entleert ist. const readable = getReadableStreamSomehow(); // 'readable' may be triggered multiple times as data is buffered in readable.on('readable', () => { let chunk; console.log('Stream is readable (new data received in buffer)'); // Use a loop to make sure we read all currently available data while (null !== (chunk = readable.read())) { console.log(`Read ${chunk.length} bytes of data...`); } }); // 'end' will be triggered once when there is no more data available readable.on('end', () => { console.log('Reached end of stream.'); }); Jeder Aufruf zu `readable.read()` gibt einen Datenblock zurück, oder `null`. Die Chunks sind nicht verkettet. Eine Schleife `while` ist notwendig, um alle Daten im Puffer zu konsumieren. Beim Lesen kann eine große Datei `.read()` zurückkommen `null`, wobei alle bisher gepufferten Inhalte verbraucht wurden, aber es gibt noch weitere Daten, die noch nicht gepuffert sind. In diesem Fall wird ein neues `'readable'` Ereignis ausgesendet, wenn sich mehr Daten im Puffer befinden. Schließlich wird das `'end'` Ereignis ausgesendet, wenn keine weiteren Daten mehr verfügbar sind. Daher ist es notwendig, um den gesamten Inhalt einer Datei aus einem zu lesen `readable`, Chunks über mehrere `'readable'` Ereignisse hinweg zu sammeln: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` Ein `Readable` Stream im Objektmodus gibt immer ein einzelnes Element aus einem Aufruf zu `readable.read(size)`zurück, unabhängig vom Wert des Arguments `size` . Wenn die Methode `readable.read()` einen Datenblock zurückgibt, wird auch ein Ereignis `'data'` ausgesendet. Rufen nach der Ausstrahlung des Ereignisses `'end'` werden zurückgerufen `null`. Es wird kein Laufzeitfehler angezeigt.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	Diese Methode ruft fn auf jedem Abschnitt des Stroms in der Reihenfolge auf und übermittelt ihm das Ergebnis aus der Berechnung des vorherigen Elements. Es gibt ein Versprechen für den Endwert der Reduktion zurück. Wird kein Anfangswert angegeben, wird das erste Stück des Stroms als Anfangswert verwendet. Ist der Strom leer, wird das Versprechen mit einer `TypeError` mit der `ERR_INVALID_ARGS` Code-Eigenschaft abgelehnt. Die Reduzierfunktion iteriert den Strom Element für Element, was bedeutet, dass es keinen Nebenläufigkeitsparameter oder Parallelität gibt. Um gleichzeitig eine Reduktion durchzuführen, kann man die asynchrone Funktion in die `readable.map` Methode extrahieren.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Entfernt alle Listener oder die der angegebenen `eventName`. Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die `EventEmitter` Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde. Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Entfernt die angegebene `listener` aus dem Listenerarray für das Ereignis mit dem Namen `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` entfernt höchstens eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene `eventName`hinzugefügt wurde, muss `removeListener()` mehrmals aufgerufen werden, um jede Instanz zu entfernen. Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Das bedeutet, dass alle oder `removeListener()` Aufrufe `removeAllListeners()`nach der Ausstrahlung und bevor der letzte Hörer die Ausführung beendet hat, sie nicht aus `emit()` dem laufenden Ablauf entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet. 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 Da Hörer über ein internes Array verwaltet werden, ändert das Aufrufen dieses Hörers die Positionsindizes jedes nach der Entfernung registrierten Listeners. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der `emitter.listeners()`-Methode zurückgegeben werden, neu erstellt werden müssen. Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt `removeListener()` die zuletzt hinzugefügte Instanz. Im Beispiel wird der `once('ping')` Listener entfernt: `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');` Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
resume()	Die Methode `readable.resume()` bewirkt, dass ein explizit pausierter `Readable` Strom wieder Ereignisse `'data'` aussendet, wodurch der Strom in den Flussmodus wechselt. Die Methode `readable.resume()` kann verwendet werden, um die Daten aus einem Strom vollständig zu konsumieren, ohne diese Daten tatsächlich zu verarbeiten: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` Die Methode `readable.resume()` hat keine Wirkung, wenn es einen `'readable'` Ereignis-Listener gibt.
setEncoding(BufferEncoding)	Die Methode `readable.setEncoding()` legt die Zeichenkodierung für die aus dem Strom `Readable` gelesenen Daten fest. Standardmäßig wird keine Codierung zugewiesen und Stromdaten werden als `Buffer` Objekte zurückgegeben. Das Setzen einer Codierung führt dazu, dass die Stromdaten als Strings der angegebenen Codierung und nicht als `Buffer` Objekte zurückgegeben werden. Zum Beispiel führt ein Aufruf `readable.setEncoding('utf8')` dazu, dass die Ausgabedaten als UTF-8-Daten interpretiert und als Zeichenketten übermittelt werden. Ein Aufruf `readable.setEncoding('hex')` führt dazu, dass die Daten im hexadezimalen String-Format codiert werden. Der Strom `Readable` verarbeitet korrekt Multibyte-Zeichen, die durch den Strom geliefert werden und sonst falsch decodiert würden, wenn sie einfach als Objekte aus dem Strom `Buffer` gezogen würden. `const readable = getReadableStreamSomehow(); readable.setEncoding('utf8'); readable.on('data', (chunk) => { assert.equal(typeof chunk, 'string'); console.log('Got %d characters of string data:', chunk.length); });`
some((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Diese Methode ist ähnlich wie `Array.prototype.some` und ruft fn auf jedem Chunk im Strom auf, bis der erwartete Rückgabewert (oder ein Truthy-Wert) erreicht ist `true` . Sobald ein FN-Call auf einen Chunk `await`Ed-Rückgabewert wahrheitsgemäß ist, wird der Stream zerstört und das Versprechen mit `true`erfüllt. Wenn keiner der fn-Aufrufe auf die Chunks einen wahrheitlichen Wert zurückgibt, wird das Versprechen mit `false`erfüllt.
take(number, Abortable)	Diese Methode gibt einen neuen Strom mit den ersten Limit-Chunks zurück.
toArray(Abortable)	Diese Methode ermöglicht es einfach, den Inhalt eines Stroms zu erhalten. Da diese Methode den gesamten Strom in den Speicher liest, werden die Vorteile von Strömen aufgehoben. Es ist für Interoperabilität und Bequemlichkeit gedacht, nicht als primäre Methode, Streams zu konsumieren.
unpipe(WritableStream)	Die Methode `readable.unpipe()` trennt einen `Writable` zuvor angelegten Strahl mittels Rohrmethode . Wenn das nicht `destination` angegeben ist, werden alle Rohre abgetrennt. Wenn das `destination` angegeben ist, aber kein Rohr dafür eingerichtet ist, bewirkt die Methode nichts. `import fs from 'node:fs'; const readable = getReadableStreamSomehow(); const writable = fs.createWriteStream('file.txt'); // All the data from readable goes into 'file.txt', // but only for the first second. readable.pipe(writable); setTimeout(() => { console.log('Stop writing to file.txt.'); readable.unpipe(writable); console.log('Manually close the file stream.'); writable.end(); }, 1000);`
unshift(any, BufferEncoding)	Das Senden `chunk` als `null` Signale das Ende des Stroms (EOF) und verhält sich gleich wie `readable.push(null)`, woraufhin keine weiteren Daten mehr geschrieben werden können. Das EOF-Signal wird ans Ende des Puffers gelegt und alle gepufferten Daten werden weiterhin entfernt. Die Methode `readable.unshift()` drückt einen Datenblock zurück in den internen Puffer. Dies ist nützlich in bestimmten Situationen, in denen ein Strom von Code verbraucht wird, der eine bestimmte Menge an Daten "entverbrauchen" muss, die er optimistisch aus der Quelle gezogen hat, damit die Daten an eine andere Partei weitergegeben werden können. Die Methode `stream.unshift(chunk)` kann nicht aufgerufen werden, nachdem das Ereignis `'end'` ausgesendet wurde, sonst wird ein Laufzeitfehler ausgelöst. Entwickler, die häufig nutzen `stream.unshift()` , sollten stattdessen in Erwägung ziehen, auf einen `Transform` Stream umzusteigen. Siehe den Abschnitt `API for stream implementers` für weitere Informationen. // Pull off a header delimited by \n\n. // Use unshift() if we get too much. // Call the callback with (error, header, stream). import { StringDecoder } from 'node:string_decoder'; function parseHeader(stream, callback) { stream.on('error', callback); stream.on('readable', onReadable); const decoder = new StringDecoder('utf8'); let header = ''; function onReadable() { let chunk; while (null !== (chunk = stream.read())) { const str = decoder.write(chunk); if (str.includes('\n\n')) { // Found the header boundary. const split = str.split(/\n\n/); header += split.shift(); const remaining = split.join('\n\n'); const buf = Buffer.from(remaining, 'utf8'); stream.removeListener('error', callback); // Remove the 'readable' listener before unshifting. stream.removeListener('readable', onReadable); if (buf.length) stream.unshift(buf); // Now the body of the message can be read from the stream. callback(null, header, stream); return; } // Still reading the header. header += str; } } } Im Gegensatz zu Push wird der Leseprozess nicht durch das Zurücksetzen des internen Lesezustands des Streams `stream.unshift(chunk)` beendet. Dies kann unerwartete Ergebnisse verursachen, wenn `readable.unshift()` er während eines Lesens (d. h. aus einer _read Implementierung auf einem benutzerdefinierten Stream ) aufgerufen wird. Das Folgen des Aufrufs mit `readable.unshift()` einem sofortigen Push setzt den Lesezustand entsprechend zurück, es ist jedoch am besten, während des Lesens einen Anruf `readable.unshift()` zu vermeiden.
wrap(ReadableStream)	Vor Node.js 0.10 implementierten Streams nicht die gesamte `node:stream` Modul-API, wie sie derzeit definiert ist. (Siehe `Compatibility` für weitere Informationen.) Wenn eine ältere Node.js-Bibliothek verwendet wird, die Ereignisse ausgibt `'data'` und eine rein beratende Pausenmethode besitzt, kann diese `readable.wrap()` Methode verwendet werden, um einen `Readable` Strom zu erstellen, der den alten Strom als Datenquelle nutzt. Sie wird selten notwendig `readable.wrap()` sein, aber die Methode wurde als Komfort für die Interaktion mit älteren Node.js-Anwendungen und Bibliotheken bereitgestellt. `import { OldReader } from './old-api-module.js'; import { Readable } from 'node:stream'; const oreader = new OldReader(); const myReader = new Readable().wrap(oreader); myReader.on('readable', () => { myReader.read(); // etc. });`
[asyncDispose]()	Ruft mit einem `AbortError` an `readable.destroy()` an an und gibt ein Versprechen zurück, das einhält, wenn der Stream beendet ist.
[asyncIterator]()
[toAsyncStreamable]()	Wenn das Flag `--experimental-stream-iter` aktiviert ist, `Readable` implementieren Streams das Protokoll `Stream.toAsyncStreamable` und ermöglichen so eine effiziente Nutzung durch die `stream/iter` API. Dies liefert einen batchbasierten asynchronen Iterator, der den internen Puffer des Stroms in `Uint8Array[]` Chargen entleert und den Versprechen-Overhead pro Chunk des Standardpfads `Symbol.asyncIterator` amortisiert. Für Byte-Mode-Ströme werden Chunks direkt als `Buffer` Instanzen (die Unterklassen sind `Uint8Array` ) ergeben. Für Objektmodus- oder kodierte Ströme wird jeder Chunk vor dem Batching auf `Uint8Array` normalisiert. Der zurückgegebene Iterator wird als validierte Quelle markiert und `from()` lässt ihn daher ohne zusätzliche Normalisierung durchleiten. `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'` Ohne die Flagge `--experimental-stream-iter` wirft `ERR_STREAM_ITER_MISSING_FLAG`das Aufrufen dieser Methode .

Geerbte Methoden

eventNames()	Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]`
getMaxListeners()	Gibt den aktuellen Maximallistenerwert für die `EventEmitter` zurück, die entweder durch `emitter.setMaxListeners(n)` oder standardmäßig auf `events.defaultMaxListeners`festgelegt ist.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Standardmäßig druckt `EventEmitter`s eine Warnung, wenn für ein bestimmtes Ereignis mehr als `10` Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der `emitter.setMaxListeners()`-Methode kann der Grenzwert für diese spezifische `EventEmitter` Instanz geändert werden. Der Wert kann auf `Infinity` (oder `0`) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben. Gibt einen Verweis auf die `EventEmitter`zurück, sodass Aufrufe verkettet werden können.
[captureRejectionSymbol](Error, string \| symbol, any[])	Die Methode `Symbol.for('nodejs.rejection')` wird aufgerufen, wenn eine Versprechensablehnung beim Aussenden eines Ereignisses auftritt und `captureRejections` auf dem Emitter aktiviert ist. Es ist möglich, anstelle von `events.captureRejectionSymbol`zu verwenden`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. } }`

Details zur Eigenschaft

closed

Es ist true danach 'close' ausgestrahlt worden.

closed: boolean

Eigenschaftswert

boolean

destroyed

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

destroyed: boolean

Eigenschaftswert

boolean

errored

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

errored: Error | null

Eigenschaftswert

Error | null

readable

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

readable: boolean

Eigenschaftswert

boolean

readableAborted

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

readableAborted: boolean

Eigenschaftswert

boolean

readableDidRead

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

readableDidRead: boolean

Eigenschaftswert

boolean

readableEncoding

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

readableEncoding: BufferEncoding | null

Eigenschaftswert

BufferEncoding | null

readableEnded

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

readableEnded: boolean

Eigenschaftswert

boolean

readableFlowing

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

readableFlowing: boolean | null

Eigenschaftswert

boolean | null

readableHighWaterMark

Gibt beim Erstellen dieses zurück highWaterMarkden Wert von Readable gegeben.

readableHighWaterMark: number

Eigenschaftswert

number

readableLength

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

readableLength: number

Eigenschaftswert

number

readableObjectMode

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

readableObjectMode: boolean

Eigenschaftswert

boolean

Details zur Methode

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Alias für emitter.on(eventName, listener).

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

Parameter

eventName: E

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

Gibt zurück

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

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

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

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

Parameter

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

options: Abortable

Gibt zurück

Duplex

ein Bach, der mit dem Strom streamzusammengesetzt ist.

destroy(Error)

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

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

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

function destroy(error?: Error): this

Parameter

error: Error

Fehler, der als Nutzlast weitergegeben wird, falls 'error'

Gibt zurück

this

drop(number, Abortable)

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

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

Parameter

limit: number

Die Anzahl der Abschnitte, die aus dem lesbaren Bereich entfernt werden müssen.

options: Abortable

Gibt zurück

Readable

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

emit(string | symbol, any[])

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

Parameter

eventName: string | symbol

args: any[]

Gibt zurück

boolean

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

Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen eventNameregistriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis.

Gibt true zurück, wenn das Ereignis Listener hatte, false andernfalls.

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

Parameter

eventName: E

args: ReadableEventMap[E]

Gibt zurück

boolean

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

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

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

Parameter

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

eine Funktion, um jeden Abschnitt des Stroms aufzurufen. Asynchron oder nicht.

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

Gibt zurück

Promise<boolean>

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

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

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

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

Parameter

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

eine Funktion, um Chunks aus dem Stream zu filtern. Asynchron oder nicht.

options: ReadableOperatorOptions

Gibt zurück

Readable

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

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>

Parameter

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

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

Gibt zurück

Promise<any>

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

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

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

Parameter

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

eine Funktion, um jeden Abschnitt des Stroms aufzurufen. Asynchron oder nicht.

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

Gibt zurück

Promise<T | undefined>

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

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

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

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

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

Parameter

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

eine Funktion, um jeden Chunk im Stream abzubilden. Könnte asynchron sein. Es könnte ein Strom oder Generator sein.

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

Gibt zurück

Readable

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

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

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

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

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

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

Parameter

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

eine Funktion, um jeden Abschnitt des Stroms aufzurufen. Asynchron oder nicht.

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

Gibt zurück

Promise<void>

Ein Versprechen, wenn der Stream zu Ende ist.

isPaused()

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

const readable = new stream.Readable();

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

function isPaused(): boolean

Gibt zurück

boolean

iterator(ReadableIteratorOptions)

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

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

Parameter

options: ReadableIteratorOptions

Gibt zurück

AsyncIterator<any>

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

number

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

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben wird, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.

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

Parameter

eventName: E

Der Name des Ereignisses, auf das gewartet wird

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

Die Ereignishandlerfunktion

Gibt zurück

number

listeners(string | symbol)

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

Parameter

eventName: string | symbol

Gibt zurück

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

listeners<E>(E)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück.

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

Parameter

eventName: E

Gibt zurück

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

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

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

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

Parameter

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

eine Funktion, um jeden Chunk im Stream abzubilden. Asynchron oder nicht.

options: ReadableOperatorOptions

Gibt zurück

Readable

ein Strom, der mit der Funktion FN abgebildet wird.

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Alias für emitter.removeListener().

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

Parameter

eventName: E

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

Gibt zurück

this

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Fügt die listener-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

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

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

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

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

Parameter

eventName: E

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

this

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Fügt eine einmaligelistener-Funktion für das Ereignis mit dem Namen eventNamehinzu. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

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

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependOnceListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

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

Parameter

eventName: E

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

this

pause()

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

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

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

function pause(): this

Gibt zurück

this

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Fügt die listener-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

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

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

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

Parameter

eventName: E

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

this

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Fügt dem beginnenden des Listenersarrays eine listenereventName Funktion für das Ereignis hinzu, das genannt wird. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

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

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

Parameter

eventName: E

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

this

push(any, BufferEncoding)

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

Parameter

chunk: any

encoding: BufferEncoding

Gibt zurück

boolean

rawListeners(string | symbol)

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

Parameter

eventName: string | symbol

Gibt zurück

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

rawListeners<E>(E)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück, einschließlich aller Wrapper (z. B. von .once()erstellt).

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

Parameter

eventName: E

Gibt zurück

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

read(number)

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

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

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

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

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

const readable = getReadableStreamSomehow();

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

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

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

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

const chunks = [];

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

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

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

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

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

function read(size?: number): any

Parameter

size: number

Optionales Argument, um anzugeben, wie viele Daten gelesen werden sollen.

Gibt zurück

any

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

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

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

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

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

Parameter

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

eine Reduziererfunktion, um jeden Chunk im Strom aufzurufen. Asynchron oder nicht.

Gibt zurück

Promise<T>

ein Versprechen für den Endwert der Reduktion.

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>

Parameter

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

initial: T

options: Abortable

Gibt zurück

Promise<T>

removeAllListeners(string | symbol)

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

Parameter

eventName: string | symbol

Gibt zurück

this

removeAllListeners<E>(E)

Entfernt alle Listener oder die der angegebenen eventName.

Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die EventEmitter Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde.

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

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

Parameter

eventName: E

Gibt zurück

this

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

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

Parameter

eventName: string | symbol

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

Gibt zurück

this

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

Entfernt die angegebene listener aus dem Listenerarray für das Ereignis mit dem Namen eventName.

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

removeListener() entfernt höchstens eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene eventNamehinzugefügt wurde, muss removeListener() mehrmals aufgerufen werden, um jede Instanz zu entfernen.

Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Das bedeutet, dass alle oder removeListener() Aufrufe removeAllListeners()nach der Ausstrahlung und bevor der letzte Hörer die Ausführung beendet hat, sie nicht aus emit() dem laufenden Ablauf entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet.

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

Da Hörer über ein internes Array verwaltet werden, ändert das Aufrufen dieses Hörers die Positionsindizes jedes nach der Entfernung registrierten Listeners. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der emitter.listeners()-Methode zurückgegeben werden, neu erstellt werden müssen.

Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt removeListener() die zuletzt hinzugefügte Instanz. Im Beispiel wird der once('ping') Listener entfernt:

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

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

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

Parameter

eventName: E

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

Gibt zurück

this

resume()

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

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

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

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

function resume(): this

Gibt zurück

this

setEncoding(BufferEncoding)

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

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

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

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

function setEncoding(encoding: BufferEncoding): this

Parameter

encoding: BufferEncoding

Die zu verwendende Codierung.

Gibt zurück

this

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

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

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

Parameter

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

eine Funktion, um jeden Abschnitt des Stroms aufzurufen. Asynchron oder nicht.

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

Gibt zurück

Promise<boolean>

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

take(number, Abortable)

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

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

Parameter

limit: number

Die Anzahl der Abschnitte, die man aus dem lesbaren Verfahren nehmen muss.

options: Abortable

Gibt zurück

Readable

Ein Stream mit limitierten Abschnitten.

toArray(Abortable)

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

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

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

Parameter

options: Abortable

Gibt zurück

Promise<any[]>

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

unpipe(WritableStream)

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

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

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

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

function unpipe(destination?: WritableStream): this

Parameter

destination: WritableStream

Optionaler spezieller Bach zum Entrohren

Gibt zurück

this

unshift(any, BufferEncoding)

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

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

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

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

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

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

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

Parameter

chunk: any

Datenblock, das auf die Lese-Warteschlange rückgängig gemacht werden kann. Für Ströme, die nicht im Objektmodus arbeiten, chunk muss es sich um {string}, {Buffer}, {TypedArray}, {DataView} oder nullhandeln. Für Objektmodus-Ströme chunk kann jeder JavaScript-Wert sein.

encoding: BufferEncoding

Codierung von String-Chunks. Muss eine gültige Buffer Codierung sein, wie 'utf8' oder 'ascii'.

wrap(ReadableStream)

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

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

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

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

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

function wrap(stream: ReadableStream): this

Parameter

stream: ReadableStream

Ein "altmodischer" lesbarer Stream

Gibt zurück

this

[asyncDispose]()

Ruft mit einem AbortError an readable.destroy() an an und gibt ein Versprechen zurück, das einhält, wenn der Stream beendet ist.

function [asyncDispose](): Promise<void>

Gibt zurück

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Gibt zurück

AsyncIterator<any>

AsyncIterator um den Strom vollständig zu konsumieren.

[toAsyncStreamable]()

Wenn das Flag --experimental-stream-iter aktiviert ist, Readable implementieren Streams das Protokoll Stream.toAsyncStreamable und ermöglichen so eine effiziente Nutzung durch die stream/iter API.

Dies liefert einen batchbasierten asynchronen Iterator, der den internen Puffer des Stroms in Uint8Array[] Chargen entleert und den Versprechen-Overhead pro Chunk des Standardpfads Symbol.asyncIterator amortisiert. Für Byte-Mode-Ströme werden Chunks direkt als Buffer Instanzen (die Unterklassen sind Uint8Array ) ergeben. Für Objektmodus- oder kodierte Ströme wird jeder Chunk vor dem Batching auf Uint8Array normalisiert.

Der zurückgegebene Iterator wird als validierte Quelle markiert und from() lässt ihn daher ohne zusätzliche Normalisierung durchleiten.

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'

Ohne die Flagge --experimental-stream-iter wirft ERR_STREAM_ITER_MISSING_FLAGdas Aufrufen dieser Methode .

function [toAsyncStreamable](): ByteReadableStream

Gibt zurück

ByteReadableStream

Details zur geerbten Methode

eventNames()

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

import { EventEmitter } from 'node:events';

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

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

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

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

Gibt zurück

(string | symbol)[]

Geerbt von Stream.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Gibt zurück

number

Geerbt von Stream.getMaxListeners

pipe<T>(T, PipeOptions)

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

Parameter

destination: T

options: PipeOptions

Gibt zurück

Geerbt von Stream.pipe

setMaxListeners(number)

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

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

function setMaxListeners(n: number): this

Parameter

n: number

Gibt zurück

this

Geerbt von Stream.setMaxListeners

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

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

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

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

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

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

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

Parameter

error: Error

event: string | symbol

args: any[]

Geerbt von Stream. [CaptureRefuctionSymbol]