Readable interface

Paket:: @azure/storage-common

Extends: Stream

Egenskaper

closed	Är `true` efter `'close'` har sänds ut.
destroyed	Är `true` efter `readable.destroy()` att ha kallats upp.
errored	Returnerar fel om strömmen har förstörts med ett fel.
readable	Är `true` om det är säkert att anropa läs, vilket betyder att strömmen inte har förstörts eller sänts `'error'` ut eller `'end'`.
readableAborted	Returnerar om strömmen förstördes eller felade innan den sändes `'end'`ut .
readableDidRead	Returnerar om det `'data'` har emitterats.
readableEncoding	Getter för egenskapen `encoding` hos en given `Readable` ström. Egenskapen `encoding` kan sättas med hjälp av setEncoding-metoden .
readableEnded	Blir när `true'end'` en händelse sänds ut.
readableFlowing	Denna egenskap speglar det aktuella tillståndet för en `Readable` bäck som beskrivs i avsnittet om tre tillstånd .
readableHighWaterMark	Returnerar värdet av `highWaterMark` passed när detta `Readable`skapas .
readableLength	Denna egenskap innehåller antalet bytes (eller objekt) i kön som är redo att läsas. Värdet ger introspektionsdata angående statusen för .`highWaterMark`
readableObjectMode	Getter för egenskapen `objectMode` hos en given `Readable` ström.

Metoder

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)` motsvarar `stream.compose(readable, s)`. Denna metod tillåter också att en `AbortSignal` tillhandahålls, vilket förstör den sammansatta strömmen när den avbryts. Se `stream.compose(...streams)` för mer information.
destroy(Error)	Förstör strömmen. Eventuellt generera en `'error'` händelse, och skicka ut en `'close'` händelse (om inte `emitClose` är satt till `false`). Efter detta anrop släpper den läsbara strömmen alla interna resurser och efterföljande anrop `push()` ignoreras. När `destroy()` alla ytterligare anrop har anropats blir no-op och inga fler fel förutom från `_destroy()` kan sändas som `'error'`. Implementörer bör inte åsidosätta denna metod, utan istället implementera `readable._destroy()`.
drop(number, Abortable)	Denna metod returnerar en ny ström med de första limit-chunks borttagna från början.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	Anropar synkront var och en av lyssnarna som registrerats för händelsen med namnet `eventName`, i den ordning de registrerades och skickar de angivna argumenten till var och en. Returnerar `true` om händelsen hade lyssnare, `false` annars. 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">)	Denna metod liknar `Array.prototype.every` och anropar fn på varje chunk i strömmen för att kontrollera om alla väntade returvärden är sanningsvärden för fn. När ett fn-anrop på ett chunk `await`ed-returvärde är falskt, förstörs strömmen och löftet uppfylls med `false`. Om alla fn-anrop på chunks returnerar ett truthy-värde, uppfylls löftet med `true`.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	Denna metod möjliggör filtrering av strömmen. För varje chunk i strömmen anropas fn-funktionen och om den returnerar ett truthy-värde kommer chunken att skickas till resultatströmmen. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara `await`ed.
find((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)
find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Denna metod liknar `Array.prototype.find` och anropar fn på varje chunk i strömmen för att hitta en chunk med ett truthy-värde för fn. När ett fn-samtals förväntade returvärde är truthy, förstörs strömmen och löftet uppfylls med ett värde för vilket fn returnerade ett truthy-värde. Om alla fn-anrop på chunkarna returnerar ett falskt värde, uppfylls löftet med `undefined`.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Denna metod returnerar en ny ström genom att applicera den givna callbacken på varje bit av strömmen och sedan platta ut resultatet. Det är möjligt att returnera en ström eller en annan iterabel eller asynkron iterabel från fn och resultatströmmarna slås ihop (plattas ut) i den returnerade strömmen.
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Denna metod möjliggör iteration av en ström. För varje chunk i strömmen kommer fn-funktionen att anropas. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara `await`ed. Denna metod skiljer sig från `for await...of` loopar genom att den valfritt kan bearbeta chunkar samtidigt. Dessutom kan en `forEach` iteration endast stoppas genom att ha passerat ett `signal` alternativ och avbryta den relaterade AbortControllern medan `for await...of` kan stoppas med `break` eller `return`. I båda fallen kommer strömmen att förstöras. Denna metod skiljer sig från att lyssna på händelsen `'data'` genom att den använder händelsen `readable` i den underliggande maskinen och kan begränsa antalet samtidiga FN-anrop .
isPaused()	Metoden `readable.isPaused()` returnerar det aktuella drifttillståndet för .`Readable` Detta används främst av mekanismen som ligger till grund för `readable.pipe()` metoden. I de flesta vanliga fall finns det ingen anledning att använda denna metod direkt. `const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false`
iterator(ReadableIteratorOptions)	Iteratorn som skapas med denna metod ger användare möjlighet att avbryta förstörelsen av strömmen om `for await...of` loopen avslutas med `return`, `break`, eller `throw`, eller om iteratorn ska förstöra strömmen om strömmen ger ett fel under iterationen.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	Returnerar antalet lyssnare som lyssnar efter händelsen med namnet `eventName`. Om `listener` anges returneras hur många gånger lyssnaren finns i listan över lyssnarna för händelsen.
listeners(string \| symbol)
listeners<E>(E)	Returnerar en kopia av matrisen med lyssnare för händelsen med namnet `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)	Denna metod möjliggör kartläggning över strömmen. Fn-funktionen anropas för varje chunk i strömmen. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara `await`ed innan det skickas till resultatströmmen.
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)	Lägger till funktionen `listener` i slutet av lyssnarmatrisen för händelsen med namnet `eventName`. Inga kontroller görs för att se om `listener` redan har lagts till. Flera anrop som skickar samma kombination av `eventName` och `listener` resulterar i att `listener` läggs till och anropas flera gånger. `server.on('connection', (stream) => { console.log('someone connected!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas. Som standard anropas händelselyssnare i den ordning de läggs till. Metoden `emitter.prependListener()` kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen. `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)	Lägger till en engångsfunktion för`listener` för händelsen med namnet `eventName`. Nästa gång `eventName` utlöses tas lyssnaren bort och anropas sedan. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas. Som standard anropas händelselyssnare i den ordning de läggs till. Metoden `emitter.prependOnceListener()` kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen. `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()	Metoden `readable.pause()` får en ström i flödesläge att sluta sända `'data'` ut händelser och byter ut från flödesläge. All data som blir tillgänglig kommer att stanna kvar i den interna bufferten. 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); }); Metoden `readable.pause()` har ingen effekt om det finns en `'readable'` händelselyssnare.
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)	Lägger till funktionen `listener` i början av lyssnarmatrisen för händelsen med namnet `eventName`. Inga kontroller görs för att se om `listener` redan har lagts till. Flera anrop som skickar samma kombination av `eventName` och `listener` resulterar i att `listener` läggs till och anropas flera gånger. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Lägger till en engångsfunktion för`listener` för händelsen med namnet `eventName` till början av lyssnarmatrisen. Nästa gång `eventName` utlöses tas lyssnaren bort och anropas sedan. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Returnerar en kopia av matrisen med lyssnare för händelsen med namnet `eventName`, inklusive eventuella omslutningar (till exempel de som skapats av `.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)	Metoden `readable.read()` läser ut data från den interna bufferten och returnerar den. Om ingen data finns tillgänglig att läsa, `null` returneras. Som standard returneras data som ett `Buffer` objekt, om inte en kodning har specificerats med metoden `readable.setEncoding()` eller om strömmen inte arbetar i objektläge. Det valfria `size` argumentet specificerar ett specifikt antal bytes att läsa. Om `size` bytes inte finns tillgängliga för läsning `null` kommer de att returneras om inte strömmen har avslutats, i vilket fall all data som finns kvar i den interna bufferten kommer att returneras. Om argumentet `size` inte specificeras kommer all data som finns i den interna bufferten att returneras. Argumentet `size` måste vara mindre än eller lika med 1 GiB. Metoden `readable.read()` ska endast anropas på `Readable` strömmar som arbetar i pausläge. I flödesläge `readable.read()` anropas automatiskt tills den interna bufferten är helt tömd. 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.'); }); Varje anrop till returnerar `readable.read()` en databit, eller `null`. Bitarna är inte sammanfogade. En `while` loop är nödvändig för att konsumera all data som för närvarande finns i bufferten. När man läser en stor fil `.read()` kan det återkomma `null`, efter att ha konsumerat allt buffrat innehåll hittills, men det finns fortfarande mer data kvar som ännu inte är buffrad. I detta fall kommer en ny `'readable'` händelse att sändas ut när det finns mer data i bufferten. Slutligen kommer händelsen `'end'` att sändas ut när det inte finns mer data att komma. Därför är det nödvändigt att samla in bitar över flera `readable` händelser för att läsa hela innehållet i `'readable'`en fil: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` En `Readable` ström i objektläge kommer alltid att returnera ett enda objekt från ett anrop till `readable.read(size)`, oavsett argumentets `size` värde. Om `readable.read()` metoden returnerar en databit kommer även en `'data'` händelse att sändas. Anrop läs efter att händelsen `'end'` har sänts kommer att återkomma `null`. Inget körtidsfel kommer att uppstå.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	Denna metod anropar fn på varje bit av strömmen i ordning och ger den resultatet från beräkningen på föregående element. Den ger ett löfte om det slutliga värdet av reduktionen. Om inget initialt värde tillhandahålls används den första delen av strömmen som startvärde. Om strömmen är tom avvisas löftet med en `TypeError` med `ERR_INVALID_ARGS` kodegenskapen. Reducerfunktionen itererar strömmen element för element, vilket innebär att det inte finns någon samtidighetsparameter eller parallellism. För att utföra en reduce samtidigt kan du extrahera metoden med asynkron funktion till `readable.map` .
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Tar bort alla lyssnare eller de som anges `eventName`. Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när den `EventEmitter` instansen skapades av någon annan komponent eller modul (t.ex. sockets eller filströmmar). Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Tar bort den angivna `listener` från lyssnarmatrisen för händelsen med namnet `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` tar högst bort en instans av en lyssnare från lyssnarmatrisen. Om en enskild lyssnare har lagts till flera gånger i lyssnarmatrisen för den angivna `eventName`måste `removeListener()` anropas flera gånger för att ta bort varje instans. När en händelse har genererats anropas alla lyssnare som är anslutna till den vid tidpunkten för avsändande i ordning. Detta innebär att inga `removeListener()` eller `removeAllListeners()` anrop efter utsändning och innan den sista lyssnaren är klar med exekveringen inte kommer att ta bort dem från `emit()` pågående process. Efterföljande händelser fungerar som förväntat. 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 Eftersom lyssnare hanteras med en intern array kommer anrop att ändra positionsindexen för alla lyssnare som registreras efter att lyssnaren tagits bort. Detta påverkar inte i vilken ordning lyssnare anropas, men det innebär att alla kopior av lyssnarmatrisen som returneras av metoden `emitter.listeners()` måste återskapas. När en enskild funktion har lagts till som hanterare flera gånger för en enskild händelse (som i exemplet nedan) tar `removeListener()` bort den senast tillagda instansen. I exemplet tas `once('ping')` lyssnaren bort: `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');` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
resume()	Metoden `readable.resume()` orsakar att en explicit pausad `Readable` ström återupptar sändande händelser `'data'` , vilket växlar strömmen till flödesläge. Metoden `readable.resume()` kan användas för att helt konsumera data från en ström utan att faktiskt bearbeta någon av dessa data: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` Metoden `readable.resume()` har ingen effekt om det finns en `'readable'` händelselyssnare.
setEncoding(BufferEncoding)	Metoden `readable.setEncoding()` sätter teckenkodningen för data som läses från strömmen `Readable` . Som standard tilldelas ingen kodning och strömdata returneras som `Buffer` objekt. Att sätta en kodning gör att strömdata returneras som strängar av den angivna kodningen istället för som `Buffer` objekt. Till exempel kommer anrop `readable.setEncoding('utf8')` att göra att utdatan tolkas som UTF-8-data och skickas som strängar. Anrop `readable.setEncoding('hex')` kommer att göra att datan kodas i hexadecimalt strängformat. Strömmen `Readable` hanterar korrekt flerbyteskaraktärer som levereras genom strömmen och som annars skulle bli felaktigt avkodade om de bara togs från strömmen som `Buffer` objekt. `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">)	Denna metod liknar `Array.prototype.some` och anropar fn på varje chunk i strömmen tills det väntade returvärdet är `true` (eller något truthy-värde). När ett fn-anrop på ett chunk `await`ed-returvärde är sanningsenligt förstörs strömmen och löftet uppfylls med `true`. Om ingen av fn-anropen på chunks ger ett truthy-värde, uppfylls löftet med `false`.
take(number, Abortable)	Denna metod returnerar en ny ström med de första gränschunkarna.
toArray(Abortable)	Denna metod gör det enkelt att få tag på innehållet i en ström. Eftersom denna metod läser in hela strömmen i minnet upphäver den fördelarna med strömmar. Det är avsett för interoperabilitet och bekvämlighet, inte som det primära sättet att konsumera strömmar.
unpipe(WritableStream)	Metoden `readable.unpipe()` lossar en `Writable` tidigare ansluten ström med rörmetoden . Om inte specificeras `destination` är alla rör lossna. Om metoden `destination` är specificerad men inget rör är uppsatt för den, så gör metoden ingenting. `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)	Att passera `chunk` som `null` signaler slutet av strömmen (EOF) och beter sig likadant som `readable.push(null)`, varefter ingen mer data kan skrivas. EOF-signalen placeras i slutet av bufferten och all buffrad data kommer fortfarande att rensas. Metoden `readable.unshift()` skickar tillbaka en databit i den interna bufferten. Detta är användbart i vissa situationer där en ström konsumeras av kod som behöver "av-konsumera" en viss mängd data som den optimistiskt har hämtat från källan, så att datan kan skickas vidare till någon annan part. Metoden `stream.unshift(chunk)` kan inte anropas efter att händelsen `'end'` har skickats ut, annars kommer ett runtime-fel att kastas. Utvecklare som ofta använder `stream.unshift()` bör överväga att byta till att använda en `Transform` stream istället. Se `API for stream implementers` avsnittet för mer information. // 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; } } } Till skillnad från push kommer inte `stream.unshift(chunk)` att avsluta läsprocessen genom att återställa strömmens interna lässtatus. Detta kan orsaka oväntade resultat om `readable.unshift()` anropas under en läsning (dvs. från en _read implementation på en anpassad ström). Att följa anropet till `readable.unshift()` med en omedelbar push återställer läsläget korrekt, men det är bäst att helt enkelt undvika att anropa `readable.unshift()` medan man utför en läsning.
wrap(ReadableStream)	Före Node.js 0.10 implementerade inte streams hela `node:stream` modul-API:et som det är definierat idag. (Se `Compatibility` för mer information.) När man använder ett äldre Node.js bibliotek som sänder händelser `'data'` och har en pausmetod som endast är rådgivande, kan metoden `readable.wrap()` användas för att skapa en `Readable` ström som använder den gamla strömmen som datakälla. Den kommer sällan att vara nödvändig att använda `readable.wrap()` , men metoden har tillhandahållits som en bekvämlighet för interaktion med äldre Node.js applikationer och bibliotek. `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]()	Ringer `readable.destroy()` med en `AbortError` och returnerar ett löfte som uppfyller när streamen är klar.
[asyncIterator]()
[toAsyncStreamable]()	När flaggan `--experimental-stream-iter` är aktiverad `Readable` implementerar strömmar protokollet `Stream.toAsyncStreamable` , vilket möjliggör effektiv konsumtion av API:et `stream/iter` . Detta ger en batchad asynkron iterator som tömmer strömmens interna buffert i `Uint8Array[]` batcher, och amortiserar den per-chunk Promise-överhead som standardvägen `Symbol.asyncIterator` har. För byte-modeströmmar ges chunks direkt som `Buffer` instanser (vilka är `Uint8Array` subklasser). För objektläges- eller kodade strömmar normaliseras varje chunk till `Uint8Array` innan batching. Den returnerade iteratorn märks som en validerad källa, så `from()` den passerar igenom utan ytterligare normalisering. `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'` Utan flaggan `--experimental-stream-iter` kastar anrop av denna metod .`ERR_STREAM_ITER_MISSING_FLAG`

Ärvda metoder

eventNames()	Returnerar en matris som visar de händelser som sändaren har registrerade lyssnare för. `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()	Returnerar det aktuella maximala lyssnarvärdet för `EventEmitter` som antingen anges av `emitter.setMaxListeners(n)` eller som standard till `events.defaultMaxListeners`.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Som standard skriver `EventEmitter`ut en varning om fler än `10` lyssnare läggs till för en viss händelse. Det här är ett användbart standardvärde som hjälper dig att hitta minnesläckor. Med metoden `emitter.setMaxListeners()` kan gränsen ändras för den här specifika `EventEmitter` instansen. Värdet kan anges till `Infinity` (eller `0`) för att ange ett obegränsat antal lyssnare. Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
[captureRejectionSymbol](Error, string \| symbol, any[])	Metoden `Symbol.for('nodejs.rejection')` anropas om en löftesavvisning sker när en händelse sänds ut och `captureRejections` aktiveras på sändaren. Det är möjligt att använda `events.captureRejectionSymbol` istället för `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. } }`

Egenskapsinformation

closed

Är true efter 'close' har sänds ut.

closed: boolean

Egenskapsvärde

boolean

destroyed

Är true efter readable.destroy() att ha kallats upp.

destroyed: boolean

Egenskapsvärde

boolean

errored

Returnerar fel om strömmen har förstörts med ett fel.

errored: Error | null

Egenskapsvärde

Error | null

readable

Är true om det är säkert att anropa läs, vilket betyder att strömmen inte har förstörts eller sänts 'error' ut eller 'end'.

readable: boolean

Egenskapsvärde

boolean

readableAborted

Returnerar om strömmen förstördes eller felade innan den sändes 'end'ut .

readableAborted: boolean

Egenskapsvärde

boolean

readableDidRead

Returnerar om det 'data' har emitterats.

readableDidRead: boolean

Egenskapsvärde

boolean

readableEncoding

Getter för egenskapen encoding hos en given Readable ström. Egenskapen encoding kan sättas med hjälp av setEncoding-metoden .

readableEncoding: BufferEncoding | null

Egenskapsvärde

BufferEncoding | null

readableEnded

Blir när true'end' en händelse sänds ut.

readableEnded: boolean

Egenskapsvärde

boolean

readableFlowing

Denna egenskap speglar det aktuella tillståndet för en Readable bäck som beskrivs i avsnittet om tre tillstånd .

readableFlowing: boolean | null

Egenskapsvärde

boolean | null

readableHighWaterMark

Returnerar värdet av highWaterMark passed när detta Readableskapas .

readableHighWaterMark: number

Egenskapsvärde

number

readableLength

Denna egenskap innehåller antalet bytes (eller objekt) i kön som är redo att läsas. Värdet ger introspektionsdata angående statusen för .highWaterMark

readableLength: number

Egenskapsvärde

number

readableObjectMode

Getter för egenskapen objectMode hos en given Readable ström.

readableObjectMode: boolean

Egenskapsvärde

boolean

Metodinformation

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

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

Parametrar

eventName: string | symbol

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

Returer

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

Parametrar

eventName: E

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

Returer

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

Denna metod tillåter också att en AbortSignal tillhandahålls, vilket förstör den sammansatta strömmen när den avbryts.

Se stream.compose(...streams) för mer information.

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

Parametrar

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

options: Abortable

Returer

Duplex

en ström som består av strömmen stream.

destroy(Error)

Förstör strömmen. Eventuellt generera en 'error' händelse, och skicka ut en 'close' händelse (om inte emitClose är satt till false). Efter detta anrop släpper den läsbara strömmen alla interna resurser och efterföljande anrop push() ignoreras.

När destroy() alla ytterligare anrop har anropats blir no-op och inga fler fel förutom från _destroy() kan sändas som 'error'.

Implementörer bör inte åsidosätta denna metod, utan istället implementera readable._destroy().

function destroy(error?: Error): this

Parametrar

error: Error

Fel som kommer att skickas som nyttolast vid 'error' event.

Returer

this

drop(number, Abortable)

Denna metod returnerar en ny ström med de första limit-chunks borttagna från början.

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

Parametrar

limit: number

Antalet delar som ska tas bort från läsbarheten.

options: Abortable

Returer

Readable

En stream med limit chunks som släpptes från början.

emit(string | symbol, any[])

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

Parametrar

eventName: string | symbol

args: any[]

Returer

boolean

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

Anropar synkront var och en av lyssnarna som registrerats för händelsen med namnet eventName, i den ordning de registrerades och skickar de angivna argumenten till var och en.

Returnerar true om händelsen hade lyssnare, false annars.

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

Parametrar

eventName: E

args: ReadableEventMap[E]

Returer

boolean

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

Denna metod liknar Array.prototype.every och anropar fn på varje chunk i strömmen för att kontrollera om alla väntade returvärden är sanningsvärden för fn. När ett fn-anrop på ett chunk awaited-returvärde är falskt, förstörs strömmen och löftet uppfylls med false. Om alla fn-anrop på chunks returnerar ett truthy-värde, uppfylls löftet med true.

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

Parametrar

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

en funktion för att anropa varje del av strömmen. Asynkron eller inte.

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

Returer

Promise<boolean>

Ett löfte som utvärderar om trueFN returnerade ett sanningsenligt värde för varje bit.

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

Denna metod möjliggör filtrering av strömmen. För varje chunk i strömmen anropas fn-funktionen och om den returnerar ett truthy-värde kommer chunken att skickas till resultatströmmen. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara awaited.

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

Parametrar

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

en funktion för att filtrera delar från strömmen. Asynkron eller inte.

options: ReadableOperatorOptions

Returer

Readable

en ström filtrerad med predikatet 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>

Parametrar

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

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

Returer

Promise<any>

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

Denna metod liknar Array.prototype.find och anropar fn på varje chunk i strömmen för att hitta en chunk med ett truthy-värde för fn. När ett fn-samtals förväntade returvärde är truthy, förstörs strömmen och löftet uppfylls med ett värde för vilket fn returnerade ett truthy-värde. Om alla fn-anrop på chunkarna returnerar ett falskt värde, uppfylls löftet med undefined.

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

Parametrar

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

en funktion för att anropa varje del av strömmen. Asynkron eller inte.

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

Returer

Promise<T | undefined>

ett löfte som utvärderar till den första chunken för vilken FN utvärderade med ett truthy-värde, eller undefined om inget element hittades.

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

Denna metod returnerar en ny ström genom att applicera den givna callbacken på varje bit av strömmen och sedan platta ut resultatet.

Det är möjligt att returnera en ström eller en annan iterabel eller asynkron iterabel från fn och resultatströmmarna slås ihop (plattas ut) i den returnerade strömmen.

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

Parametrar

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

en funktion för att kartlägga varje chunk i strömmen. Kan vara asynk. Det kan vara en bäck eller generator.

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

Returer

Readable

en ström plattmappad med funktionen fn.

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

Denna metod möjliggör iteration av en ström. För varje chunk i strömmen kommer fn-funktionen att anropas. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara awaited.

Denna metod skiljer sig från for await...of loopar genom att den valfritt kan bearbeta chunkar samtidigt. Dessutom kan en forEach iteration endast stoppas genom att ha passerat ett signal alternativ och avbryta den relaterade AbortControllern medan for await...of kan stoppas med break eller return. I båda fallen kommer strömmen att förstöras.

Denna metod skiljer sig från att lyssna på händelsen 'data' genom att den använder händelsen readable i den underliggande maskinen och kan begränsa antalet samtidiga FN-anrop .

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

Parametrar

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

en funktion för att anropa varje del av strömmen. Asynkron eller inte.

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

Returer

Promise<void>

ett löfte när streamen är slut.

isPaused()

Metoden readable.isPaused() returnerar det aktuella drifttillståndet för .Readable Detta används främst av mekanismen som ligger till grund för readable.pipe() metoden. I de flesta vanliga fall finns det ingen anledning att använda denna metod direkt.

const readable = new stream.Readable();

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

function isPaused(): boolean

Returer

boolean

iterator(ReadableIteratorOptions)

Iteratorn som skapas med denna metod ger användare möjlighet att avbryta förstörelsen av strömmen om for await...of loopen avslutas med return, break, eller throw, eller om iteratorn ska förstöra strömmen om strömmen ger ett fel under iterationen.

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

Parametrar

options: ReadableIteratorOptions

Returer

AsyncIterator<any>

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

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

Parametrar

eventName: string | symbol

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

Returer

number

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

Returnerar antalet lyssnare som lyssnar efter händelsen med namnet eventName. Om listener anges returneras hur många gånger lyssnaren finns i listan över lyssnarna för händelsen.

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

Parametrar

eventName: E

Namnet på händelsen som lyssnas efter

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

Händelsehanterarfunktionen

Returer

number

listeners(string | symbol)

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

Parametrar

eventName: string | symbol

Returer

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

listeners<E>(E)

Returnerar en kopia av matrisen med lyssnare för händelsen med namnet 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[]

Parametrar

eventName: E

Returer

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

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

Denna metod möjliggör kartläggning över strömmen. Fn-funktionen anropas för varje chunk i strömmen. Om fn-funktionen returnerar ett löfte – kommer det löftet att vara awaited innan det skickas till resultatströmmen.

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

Parametrar

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

en funktion för att kartlägga varje chunk i strömmen. Asynkron eller inte.

options: ReadableOperatorOptions

Returer

Readable

en ström mappad med funktionen fn.

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Alias för emitter.removeListener().

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

Parametrar

eventName: E

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

Returer

this

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Lägger till funktionen listener i slutet av lyssnarmatrisen för händelsen med namnet eventName. Inga kontroller görs för att se om listener redan har lagts till. Flera anrop som skickar samma kombination av eventName och listener resulterar i att listener läggs till och anropas flera gånger.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

Som standard anropas händelselyssnare i den ordning de läggs till. Metoden emitter.prependListener() kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen.

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

Parametrar

eventName: E

Namnet på händelsen.

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

Återanropsfunktionen

Returer

this

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Lägger till en engångsfunktion förlistener för händelsen med namnet eventName. Nästa gång eventName utlöses tas lyssnaren bort och anropas sedan.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

Som standard anropas händelselyssnare i den ordning de läggs till. Metoden emitter.prependOnceListener() kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen.

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

Parametrar

eventName: E

Namnet på händelsen.

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

Återanropsfunktionen

Returer

this

pause()

Metoden readable.pause() får en ström i flödesläge att sluta sända 'data' ut händelser och byter ut från flödesläge. All data som blir tillgänglig kommer att stanna kvar i den interna bufferten.

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

Metoden readable.pause() har ingen effekt om det finns en 'readable' händelselyssnare.

function pause(): this

Returer

this

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Lägger till funktionen listener i början av lyssnarmatrisen för händelsen med namnet eventName. Inga kontroller görs för att se om listener redan har lagts till. Flera anrop som skickar samma kombination av eventName och listener resulterar i att listener läggs till och anropas flera gånger.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: E

Namnet på händelsen.

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

Återanropsfunktionen

Returer

this

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Lägger till en engångsfunktion förlistener för händelsen med namnet eventName till början av lyssnarmatrisen. Nästa gång eventName utlöses tas lyssnaren bort och anropas sedan.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: E

Namnet på händelsen.

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

Återanropsfunktionen

Returer

this

push(any, BufferEncoding)

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

Parametrar

chunk: any

encoding: BufferEncoding

Returer

boolean

rawListeners(string | symbol)

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

Parametrar

eventName: string | symbol

Returer

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

rawListeners<E>(E)

Returnerar en kopia av matrisen med lyssnare för händelsen med namnet eventName, inklusive eventuella omslutningar (till exempel de som skapats av .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[]

Parametrar

eventName: E

Returer

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

read(number)

Metoden readable.read() läser ut data från den interna bufferten och returnerar den. Om ingen data finns tillgänglig att läsa, null returneras. Som standard returneras data som ett Buffer objekt, om inte en kodning har specificerats med metoden readable.setEncoding() eller om strömmen inte arbetar i objektläge.

Det valfria size argumentet specificerar ett specifikt antal bytes att läsa. Om size bytes inte finns tillgängliga för läsning null kommer de att returneras om inte strömmen har avslutats, i vilket fall all data som finns kvar i den interna bufferten kommer att returneras.

Om argumentet size inte specificeras kommer all data som finns i den interna bufferten att returneras.

Argumentet size måste vara mindre än eller lika med 1 GiB.

Metoden readable.read() ska endast anropas på Readable strömmar som arbetar i pausläge. I flödesläge readable.read() anropas automatiskt tills den interna bufferten är helt tömd.

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

Varje anrop till returnerar readable.read() en databit, eller null. Bitarna är inte sammanfogade. En while loop är nödvändig för att konsumera all data som för närvarande finns i bufferten. När man läser en stor fil .read() kan det återkomma null, efter att ha konsumerat allt buffrat innehåll hittills, men det finns fortfarande mer data kvar som ännu inte är buffrad. I detta fall kommer en ny 'readable' händelse att sändas ut när det finns mer data i bufferten. Slutligen kommer händelsen 'end' att sändas ut när det inte finns mer data att komma.

Därför är det nödvändigt att samla in bitar över flera readable händelser för att läsa hela innehållet i 'readable'en fil:

const chunks = [];

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

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

En Readable ström i objektläge kommer alltid att returnera ett enda objekt från ett anrop till readable.read(size), oavsett argumentets size värde.

Om readable.read() metoden returnerar en databit kommer även en 'data' händelse att sändas.

Anrop läs efter att händelsen 'end' har sänts kommer att återkomma null. Inget körtidsfel kommer att uppstå.

function read(size?: number): any

Parametrar

size: number

Valfritt argument för att specificera hur mycket data som ska läsas.

Returer

any

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

Denna metod anropar fn på varje bit av strömmen i ordning och ger den resultatet från beräkningen på föregående element. Den ger ett löfte om det slutliga värdet av reduktionen.

Om inget initialt värde tillhandahålls används den första delen av strömmen som startvärde. Om strömmen är tom avvisas löftet med en TypeError med ERR_INVALID_ARGS kodegenskapen.

Reducerfunktionen itererar strömmen element för element, vilket innebär att det inte finns någon samtidighetsparameter eller parallellism. För att utföra en reduce samtidigt kan du extrahera metoden med asynkron funktion till readable.map .

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

Parametrar

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

en reducerande funktion för att kalla över varje chunk i strömmen. Asynkron eller inte.

Returer

Promise<T>

ett löfte om det slutliga värdet av reduktionen.

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>

Parametrar

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

initial: T

options: Abortable

Returer

Promise<T>

removeAllListeners(string | symbol)

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

Parametrar

eventName: string | symbol

Returer

this

removeAllListeners<E>(E)

Tar bort alla lyssnare eller de som anges eventName.

Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när den EventEmitter instansen skapades av någon annan komponent eller modul (t.ex. sockets eller filströmmar).

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: E

Returer

this

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

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

Parametrar

eventName: string | symbol

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

Returer

this

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

Tar bort den angivna listener från lyssnarmatrisen för händelsen med namnet eventName.

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

removeListener() tar högst bort en instans av en lyssnare från lyssnarmatrisen. Om en enskild lyssnare har lagts till flera gånger i lyssnarmatrisen för den angivna eventNamemåste removeListener() anropas flera gånger för att ta bort varje instans.

När en händelse har genererats anropas alla lyssnare som är anslutna till den vid tidpunkten för avsändande i ordning. Detta innebär att inga removeListener() eller removeAllListeners() anrop efter utsändning och innan den sista lyssnaren är klar med exekveringen inte kommer att ta bort dem från emit() pågående process. Efterföljande händelser fungerar som förväntat.

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

Eftersom lyssnare hanteras med en intern array kommer anrop att ändra positionsindexen för alla lyssnare som registreras efter att lyssnaren tagits bort. Detta påverkar inte i vilken ordning lyssnare anropas, men det innebär att alla kopior av lyssnarmatrisen som returneras av metoden emitter.listeners() måste återskapas.

När en enskild funktion har lagts till som hanterare flera gånger för en enskild händelse (som i exemplet nedan) tar removeListener() bort den senast tillagda instansen. I exemplet tas once('ping') lyssnaren bort:

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: E

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

Returer

this

resume()

Metoden readable.resume() orsakar att en explicit pausad Readable ström återupptar sändande händelser 'data' , vilket växlar strömmen till flödesläge.

Metoden readable.resume() kan användas för att helt konsumera data från en ström utan att faktiskt bearbeta någon av dessa data:

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

Metoden readable.resume() har ingen effekt om det finns en 'readable' händelselyssnare.

function resume(): this

Returer

this

setEncoding(BufferEncoding)

Metoden readable.setEncoding() sätter teckenkodningen för data som läses från strömmen Readable .

Som standard tilldelas ingen kodning och strömdata returneras som Buffer objekt. Att sätta en kodning gör att strömdata returneras som strängar av den angivna kodningen istället för som Buffer objekt. Till exempel kommer anrop readable.setEncoding('utf8') att göra att utdatan tolkas som UTF-8-data och skickas som strängar. Anrop readable.setEncoding('hex') kommer att göra att datan kodas i hexadecimalt strängformat.

Strömmen Readable hanterar korrekt flerbyteskaraktärer som levereras genom strömmen och som annars skulle bli felaktigt avkodade om de bara togs från strömmen som Buffer objekt.

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

Parametrar

encoding: BufferEncoding

Kodningen som ska användas.

Returer

this

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

Denna metod liknar Array.prototype.some och anropar fn på varje chunk i strömmen tills det väntade returvärdet är true (eller något truthy-värde). När ett fn-anrop på ett chunk awaited-returvärde är sanningsenligt förstörs strömmen och löftet uppfylls med true. Om ingen av fn-anropen på chunks ger ett truthy-värde, uppfylls löftet med false.

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

Parametrar

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

en funktion för att anropa varje del av strömmen. Asynkron eller inte.

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

Returer

Promise<boolean>

Ett löfte som utvärderar om trueFN returnerade ett sanningsenligt värde för åtminstone en av chunks.

take(number, Abortable)

Denna metod returnerar en ny ström med de första gränschunkarna.

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

Parametrar

limit: number

Antalet delar som ska tas från det läsbara.

options: Abortable

Returer

Readable

En stream med begränsade bitar tagna.

toArray(Abortable)

Denna metod gör det enkelt att få tag på innehållet i en ström.

Eftersom denna metod läser in hela strömmen i minnet upphäver den fördelarna med strömmar. Det är avsett för interoperabilitet och bekvämlighet, inte som det primära sättet att konsumera strömmar.

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

Parametrar

options: Abortable

Returer

Promise<any[]>

ett löfte som innehåller en array med innehållet i strömmen.

unpipe(WritableStream)

Metoden readable.unpipe() lossar en Writable tidigare ansluten ström med rörmetoden .

Om inte specificeras destination är alla rör lossna.

Om metoden destination är specificerad men inget rör är uppsatt för den, så gör metoden ingenting.

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

Parametrar

destination: WritableStream

Valfri specifik ström att avpipa

Returer

this

unshift(any, BufferEncoding)

Att passera chunk som null signaler slutet av strömmen (EOF) och beter sig likadant som readable.push(null), varefter ingen mer data kan skrivas. EOF-signalen placeras i slutet av bufferten och all buffrad data kommer fortfarande att rensas.

Metoden readable.unshift() skickar tillbaka en databit i den interna bufferten. Detta är användbart i vissa situationer där en ström konsumeras av kod som behöver "av-konsumera" en viss mängd data som den optimistiskt har hämtat från källan, så att datan kan skickas vidare till någon annan part.

Metoden stream.unshift(chunk) kan inte anropas efter att händelsen 'end' har skickats ut, annars kommer ett runtime-fel att kastas.

Utvecklare som ofta använder stream.unshift() bör överväga att byta till att använda en Transform stream istället. Se API for stream implementers avsnittet för mer information.

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

Till skillnad från push kommer inte stream.unshift(chunk) att avsluta läsprocessen genom att återställa strömmens interna lässtatus. Detta kan orsaka oväntade resultat om readable.unshift() anropas under en läsning (dvs. från en _read implementation på en anpassad ström). Att följa anropet till readable.unshift() med en omedelbar push återställer läsläget korrekt, men det är bäst att helt enkelt undvika att anropa readable.unshift() medan man utför en läsning.

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

Parametrar

chunk: any

En databit som ska återställas till läskön. För strömmar som inte arbetar i objektläge chunk måste det vara en {sträng}, {Buffer}, {TypedArray}, {DataView} eller null. För objektlägesströmmar chunk kan vara valfritt JavaScript-värde.

encoding: BufferEncoding

Kodning av strängbitar. Måste vara en giltig Buffer kodning, såsom 'utf8' eller 'ascii'.

wrap(ReadableStream)

Före Node.js 0.10 implementerade inte streams hela node:stream modul-API:et som det är definierat idag. (Se Compatibility för mer information.)

När man använder ett äldre Node.js bibliotek som sänder händelser 'data' och har en pausmetod som endast är rådgivande, kan metoden readable.wrap() användas för att skapa en Readable ström som använder den gamla strömmen som datakälla.

Den kommer sällan att vara nödvändig att använda readable.wrap() , men metoden har tillhandahållits som en bekvämlighet för interaktion med äldre Node.js applikationer och bibliotek.

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

Parametrar

stream: ReadableStream

En "gammaldags" läsbar ström

Returer

this

[asyncDispose]()

Ringer readable.destroy() med en AbortError och returnerar ett löfte som uppfyller när streamen är klar.

function [asyncDispose](): Promise<void>

Returer

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Returer

AsyncIterator<any>

AsyncIterator för att helt konsumera strömmen.

[toAsyncStreamable]()

När flaggan --experimental-stream-iter är aktiverad Readable implementerar strömmar protokollet Stream.toAsyncStreamable , vilket möjliggör effektiv konsumtion av API:et stream/iter .

Detta ger en batchad asynkron iterator som tömmer strömmens interna buffert i Uint8Array[] batcher, och amortiserar den per-chunk Promise-överhead som standardvägen Symbol.asyncIterator har. För byte-modeströmmar ges chunks direkt som Buffer instanser (vilka är Uint8Array subklasser). För objektläges- eller kodade strömmar normaliseras varje chunk till Uint8Array innan batching.

Den returnerade iteratorn märks som en validerad källa, så from() den passerar igenom utan ytterligare normalisering.

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'

Utan flaggan --experimental-stream-iter kastar anrop av denna metod .ERR_STREAM_ITER_MISSING_FLAG

function [toAsyncStreamable](): ByteReadableStream

Returer

ByteReadableStream

Ärvd metodinformation

eventNames()

Returnerar en matris som visar de händelser som sändaren har registrerade lyssnare för.

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

Returer

(string | symbol)[]

Ärvt från Stream.eventNames

getMaxListeners()

Returnerar det aktuella maximala lyssnarvärdet för EventEmitter som antingen anges av emitter.setMaxListeners(n) eller som standard till events.defaultMaxListeners.

function getMaxListeners(): number

Returer

number

Ärvt från Stream.getMaxListeners

pipe<T>(T, PipeOptions)

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

Parametrar

destination: T

options: PipeOptions

Returer

Ärvt från Stream.pipe

setMaxListeners(number)

Som standard skriver EventEmitterut en varning om fler än 10 lyssnare läggs till för en viss händelse. Det här är ett användbart standardvärde som hjälper dig att hitta minnesläckor. Med metoden emitter.setMaxListeners() kan gränsen ändras för den här specifika EventEmitter instansen. Värdet kan anges till Infinity (eller 0) för att ange ett obegränsat antal lyssnare.

Returnerar en referens till EventEmitter, så att anrop kan länkas.

function setMaxListeners(n: number): this

Parametrar

n: number

Returer

this

Ärvt från Stream.setMaxListeners

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

Metoden Symbol.for('nodejs.rejection') anropas om en löftesavvisning sker när en händelse sänds ut och captureRejections aktiveras på sändaren. Det är möjligt att använda events.captureRejectionSymbol istället för Symbol.for('nodejs.rejection').

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

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

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

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

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

Parametrar

error: Error

event: string | symbol

args: any[]

Ärvd från Stream. [fångare, avvisningssymbol]