Readable class

Paket:
@azure/storage-common
Extends

Stream

Konstruktorer

Readable(ReadableOptions<Readable>)

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 Readableskapas .
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)
compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (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.

Mer information finns i stream.compose(...streams).
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])
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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.
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.
find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)
find<T>((data: any, options?: Abortable) => data, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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

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

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 .
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

En verktygsmetod för att skapa läsbara strömmar av iteratorer.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

En verktygsmetod för att skapa en Readable från ett webb.ReadableStream
isDisturbed(ReadableStream<any> | ReadableStream)

Returnerar oavsett om strömmen har lästs från eller avbrutits.
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)
listeners(string | symbol)
listeners<E>(E)
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.
off(string | symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)
on(string | symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)
once(string | symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)
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)
prependOnceListener(string | symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)
push(any, BufferEncoding)
rawListeners(string | symbol)
rawListeners<E>(E)
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)
removeListener(string | symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)
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, "signal" | "concurrency">)

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.
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.
toWeb(ReadableStream, ReadableToWebOptions)

En nyttometod för att skapa ett webbnät ReadableStream från en Readable.
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.
});
[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 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.
[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.
  }
}

Konstruktorinformation

Readable(ReadableOptions<Readable>) 

new Readable(options?: ReadableOptions<Readable>)

Parametrar

options

ReadableOptions<Readable>

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

Egenskapsvärde

null | Error

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

Egenskapsvärde

null | BufferEncoding

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

Egenskapsvärde

null | boolean

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (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.

Mer information finns i stream.compose(...streams).

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

Parametrar

stream

WritableStream | WritableStream<any> | TransformStream<any, any> | (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): Readable

Parametrar

error

Error

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

Returer

Readable

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

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

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

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

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

Parametrar

fn

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

options

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

Returer

Promise<any>

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

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

Parametrar

fn

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

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

options

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

Returer

Promise<undefined | T>

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

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

Returer

Readable

en ström plattmappad med funktionen fn.

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

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

Returer

Promise<void>

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

from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

En verktygsmetod för att skapa läsbara strömmar av iteratorer.

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

Parametrar

iterable

Iterable<any> | AsyncIterable<any>

Objekt som implementerar det Symbol.asyncIterator eller Symbol.iterator iterabla protokollet. Utsänder en 'fel'-händelse om ett nollvärde passeras.

options

ReadableOptions<Readable>

Alternativ som erbjuds till new stream.Readable([options]). Som standard kommer att Readable.from() sätta options.objectMode till true, om inte detta uttryckligen är valt bort genom att sätta options.objectMode till false.

Returer

Readable

fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

En verktygsmetod för att skapa en Readable från ett webb.ReadableStream

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

Parametrar

readableStream

ReadableStream<any>

options

Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">

Returer

Readable

isDisturbed(ReadableStream<any> | ReadableStream)

Returnerar oavsett om strömmen har lästs från eller avbrutits.

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

Parametrar

stream

ReadableStream<any> | ReadableStream

Returer

boolean

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, undefined, any>

Parametrar

options

ReadableIteratorOptions

Returer

AsyncIterator<any, undefined, 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) 

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

number

listeners(string | symbol) 

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

Parametrar

eventName

string | symbol

Returer

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

listeners<E>(E) 

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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

Returer

Readable

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

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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) 

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

Parametrar

eventName

string | symbol

Returer

Readable

removeAllListeners<E>(E) 

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

Parametrar

eventName

E

Returer

Readable

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

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

Parametrar

eventName

string | symbol

listener

(args: any[]) => void

Returer

Readable

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

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

Parametrar

eventName

E

listener

(args: ReadableEventMap[E]) => void

Returer

Readable

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

Returer

Readable

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

Parametrar

encoding

BufferEncoding

Kodningen som ska användas.

Returer

Readable

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

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

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.

toWeb(ReadableStream, ReadableToWebOptions)

En nyttometod för att skapa ett webbnät ReadableStream från en Readable.

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

Parametrar

streamReadable

ReadableStream

options

ReadableToWebOptions

Returer

ReadableStream<any>

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

Parametrar

destination

WritableStream

Valfri specifik ström att avpipa

Returer

Readable

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

Parametrar

stream

ReadableStream

En "gammaldags" läsbar ström

Returer

Readable

[asyncIterator]() 

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

Returer

AsyncIterator<any, undefined, 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

T

Ä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): Readable

Parametrar

n

number

Returer

Readable

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

Ärvt från Stream.__@captureRejectionSymbol@180