Readable class

Csomag:
@azure/storage-common
Extends

Stream

Konstruktorok

Readable(ReadableOptions<Readable>)

Tulajdonságok

closed

A true kibocsátás után 'close' is kibocsátott.
destroyed

A true hívás után readable.destroy() történt.
errored

Hibát ad, ha a stream hibával megsemmisült.
readable

Ha true biztonságos a olvasás hívása, ami azt jelenti, hogy a stream nem sérült meg vagy nem bocsátott 'error' ki, vagy 'end'.
readableAborted

Visszaadja azt a reakciót, hogy a stream megsemmisült-e vagy hibázott az emitáció 'end'előtt.
readableDidRead

Visszajelzés, hogy kibocsátották-e 'data' .
readableEncoding

Getter egy adott Readable áram tulajdonságáraencoding. A encoding tulajdonság a setEncoding módszerrel állítható be.
readableEnded

Akkor válik, true amikor 'end' az esemény kibocsátódik.
readableFlowing

Ez a tulajdonság tükrözi a Readable patak aktuális állapotát, ahogy azt a Három állapot szakaszban leírjuk.
readableHighWaterMark

A passz értékét highWaterMark adja vissza, amikor ezt Readablelétrehozza.
readableLength

Ez a tulajdonság tartalmazza a sorban lévő bájtok (vagy objektumok) számát, amelyek készen állnak az olvasásra. Az érték introspektív adatokat ad a . highWaterMarkállapotáról.
readableObjectMode

Getter egy adott Readable áram tulajdonságáraobjectMode.

Metódusok

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)egyenértékű a .-nak.stream.compose(readable, s)

Ez a módszer lehetővé teszi egy AbortSignal adás biztosítását is, amely megszakítás esetén elpusztítja a keletkezett folyamot.

További információért lásd a stream.compose(...streams) jelű részt.
destroy(Error)

Pusztítsd el a patakot. Opcionálisan kibocsáthatsz egy 'error' eseményt, és kibocsáthatsz egy 'close' eseményt (kivéve, ha emitClose beállított-a false). E hívás után az olvasható stream minden belső erőforrást felszabadít, és a következő hívásokat push() figyelmen kívül hagyják.

Ha destroy() behívták, további hívások no-op lesznek, és további hibák nem kerülhetnek ki, kivéve , _destroy() mint 'error'.

A végrehajtóknak nem szabad felülírniuk ezt a módszert, hanem inkább implementálniuk readable._destroy().
drop(number, Abortable)

Ez a módszer új streamet ad vissza, amelynek első limit chunkjai már az elejétől elhagyják.
emit(string | symbol, any[])
emit<E>(E, ReadableEventMap[E])
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Ez a módszer hasonló, és Array.prototype.every minden egyes darabon fn-t hív, hogy ellenőrizze, minden várt visszatérési érték igaz-e fn esetén. Ha egy fn hívás egy chunk awaited visszatérítési érték hamis, a stream megsemmisül, és az ígéret teljesül .false Ha az összes fn hívás a chunkokban igazságos értéket ad, az ígéret teljesül .true
filter((data: any, options?: Abortable) => boolean | Promise<boolean>, ReadableOperatorOptions)

Ez a módszer lehetővé teszi az áramlat szűrését. Minden egyes darab esetén az fn függvényt hívják, és ha igazságos értéket ad vissza, akkor a chunk átkerül az eredményfolyamhoz. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül.
find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)
find<T>((data: any, options?: Abortable) => data, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Ez a módszer hasonló a Array.prototype.findfn-hez minden egyes szakaszon, és fn-t hív, hogy megtaláljon egy chunkot, amelynek igazságértéke fn-hez. Ha egy fn hívás várt visszatérési értéke igaz, a stream megsemmisül, és az ígéret teljesül azzal az értékkel, amelyért a fn igazságos értéket adott vissza. Ha az összes fn hívás a chunkokra hamis értéket ad, az ígéret teljesül.undefined
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Ez a módszer új streamet ad vissza úgy, hogy a megadott visszahívást alkalmazza az áram egyes szakaszára, majd lapítja az eredményt.

Lehetséges egy streamet vagy más, iterable vagy asszinkron iterálható fn-ből visszaadni, és az eredmény folyamai összeolvadnak (lapítják) a visszaadott folyammal.
forEach((data: any, options?: Abortable) => void | Promise<void>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Ez a módszer lehetővé teszi egy stream iterálását. Az áramfolyam minden egyes részéhez az fn függvény lesz meghívva. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül.

Ez a módszer eltér a for await...of hurkoktól, mivel opcionálisan egyszerre feldolgozhatja a darabokat. Ezen felül egy forEach iteráció csak akkor állíthat meg, ha egy signal opciót átsiklott, és megszakítja a kapcsolódó AbortControllert, miközben for await...of a megállítható returnvagy -vel break is megállítható. Mindkét esetben a patak tönkretelik.

Ez a módszer eltér az esemény meghallgatásától 'data' , mivel readable az eseményt használja az alatta lévő gépészetben, és korlátozhatja az egyidejű fn hívások számát.
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Egy hasznos módszer Readable Streamek létrehozására iterátorokból.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Egy hasznos módszer a webből ReadableStreamtörténő létrehozásáraReadable.
isDisturbed(ReadableStream<any> | ReadableStream)

Visszaadja azt is, hogy a streamet elolvasták vagy törölték.
isPaused()

A readable.isPaused() módszer visszaadja a jelenlegi működési állapotot .Readable Ezt elsősorban a módszer mögött álló mechanizmus readable.pipe() használja. A legtöbb tipikus esetben nincs ok közvetlenül alkalmazni ezt a módszert.

const readable = new stream.Readable();

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

Ezzel a módszerrel létrehozott iterátor lehetőséget ad a felhasználóknak, hogy töröljék az áramfolyam megsemmisítését, ha a for await...of hurkot return, break, vagy throw, vagy az iterátor megsemmisíti, ha az áramlat hibát adott ki az iteráció során.
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)

Ez a módszer lehetővé teszi a padi leképezést az áramlat felett. Az fn függvényt minden egyes szakaszra hívják meg a streamben. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül, mielőtt átadná az eredményfolyamnak.
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()

A readable.pause() módszer arra készteti, hogy egy áramlat áramlat megállítja az 'data' események kibocsátását, és kivált az áramlási módból. Bármilyen elérhetővé vált adat a belső pufferben marad.

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

A readable.pause() módszernek nincs hatása, ha van eseményhallgató 'readable' .
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)

A readable.read() módszer kiolvassa az adatokat a belső pufferből, és visszaadja azokat. Ha nincs elérhető olvasható adat, null visszaküldik. Alapértelmezés szerint az adat objektumként kerül vissza Buffer , hacsak nem volt kódolás a readable.setEncoding() metódus segítségével, vagy az áramfolyam objektum módban működik.

Az opcionális size érv meghatározott számú bájtszámot határoz meg az olvasásra. Ha size a bájtok nem olvashatók, null akkor visszaküldik, hacsak az folyam nem ért véget, ekkor az összes belső pufferben maradt adat visszakerül.

Ha az size érv nincs megadva, az összes belső pufferben lévő adat visszakerül.

Az érvnek size kisebb vagy egyenlőnek kell lennie, mint 1 GiB.

A readable.read() módszert csak a szünetes módban működő streameken kell meghívni Readable . Áramlási módban readable.read() automatikusan hívják, amíg a belső puffer teljesen le nem merül.

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

Minden hívás readable.read() egy adatdarabot, vagyis nullvisszaad . A darabok nincsenek összekötve. A pufferben jelenleg lévő összes adat fogyasztásához hurokra van szükség while . Egy nagy fájl .read() olvasása esetén előfordulhat, hogy nullaz eddig minden pufferelt tartalmat elfogyasztotta, de még van még több adat, amelyet még nem puffereltek. Ebben az esetben új 'readable' esemény indul, amikor több adat van a pufferben. Végül az 'end' esemény akkor fog kibocsátásra kerülni, amikor már nincs több adat.

Ezért ahhoz, hogy egy fájl teljes tartalmát olvassuk az - readableről, több eseményre történő darabokat kell gyűjteni 'readable' :

const chunks = [];

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

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

Egy Readable objektum módban lévő stream mindig egyetlen elemet ad vissza egy hívásból , függetlenül readable.read(size)az size argumentus értékétől.

Ha a readable.read() módszer egy adatdarabot ad vissza, akkor egy 'data' esemény is kiemésztődik.

Az esemény kisugárzása után olvasott hívás 'end' visszatérnull. Futásidőben nem fog hiba felmerülni.
reduce<T>((previous: any, data: any, options?: Abortable) => T)

Ez a módszer sorrendben hívja meg a fn-t az áramfolyam minden egyes részén, és továbbítja neki az előző elem számításának eredményét. Ígéretet ad a redukció végső értékére.

Ha nem adunk ki kezdeti értéket, akkor az adatfolyam első darabját használják kiindulóként. Ha az áramlat üres, az ígéret a TypeErrorERR_INVALID_ARGS kód tulajdonsággal együtt elutasítódik.

A reduktorfüggvény elemenként iterálja az áramlatot, ami azt jelenti, hogy nincs egyidejű paraméter vagy párhuzamosság. A redukció egyidejű végrehajtásához az aszinkron függvényt kihúzhatod a readable.map metódushoz.
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()

A readable.resume() módszer egy explicit szünetelt Readable folyamot indít újra, hogy az emitációs 'data' események folytassa, így az áramlat áramlási módba vált.

A readable.resume() módszer felhasználható arra, hogy teljes mértékben felhasználja az adatfolyamot anélkül, hogy tényleges feldolgozná ezeket az adatokat:

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

A readable.resume() módszernek nincs hatása, ha van eseményhallgató 'readable' .
setEncoding(BufferEncoding)

A readable.setEncoding() módszer beállítja a karakterkódolást az adatfolyamból olvasott Readable adatokhoz.

Alapértelmezés szerint nem rendelnek hozzá kódolást, és az adatfolyam adatai objektumként Buffer kerülnek vissza. Kódolás beállítása miatt az adatfolyam adatai a megadott kódolás stringjeiként térnek vissza, nem objektumként Buffer . Például a hívás readable.setEncoding('utf8') esetén a kimeneti adatokat UTF-8 adatként értelmezik, és stringként továbbítják. A hívás readable.setEncoding('hex') esetén az adat hexadecimális string formátumban kódolódik.

Az Readable áramlat megfelelően kezeli a többbájtos karaktereket, amelyeket az áramlaton keresztül továbbítanak, és egyébként rosszul dekódolnának, ha csak objektumként húznák ki őket.Buffer

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

Ez a módszer hasonló és Array.prototype.somefn-t hív minden darabra a folyamban, amíg a várt visszatérés értéke (vagy bármely igazságos érték) nem lesz true (vagy bármely igazságos érték). Ha egy fn hívás egy chunk awaited visszatérési értéken igaz, a stream megsemmisül, és az ígéret teljesül .true Ha a fn hívások egyike sem ad igazságos értéket, az ígéret teljesít .false
take(number, Abortable)

Ez a módszer egy új adatfolyamot ad vissza az első limit chunkokkal.
toArray(Abortable)

Ez a módszer lehetővé teszi, hogy könnyen megszerezzék egy folyam tartalmát.

Mivel ez a módszer az egész streamet olvassa be a memóriába, semlegesíti az áramlatok előnyeit. Ez az interoperabilitásra és a kényelmi megoldásra van szánva, nem pedig az elsődleges módnak a streamek fogyasztásának.
toWeb(ReadableStream, ReadableToWebOptions)

Egy hasznos módszer egy webet ReadableStream létrehozni egy Readable.
unpipe(WritableStream)

A readable.unpipe() módszer leválasztja a Writable korábban csatlakoztatott víz vízvezeték-módszert.

Ha destination nincs megadva, akkor minden cső leválik.

Ha destination meg van határozva, de nincs beállítva cső rá, akkor a módszer semmit sem csinál.

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)

Jelként továbbítva chunknull az áramlat végét (EOF), és úgy viselkedik, mint readable.push(null), utána több adat nem írható ki. Az EOF jelet a puffer végén helyezzük, és a pufferelt adatok továbbra is elöblíthetők.

A readable.unshift() módszer egy adattömböt visszatol a belső pufferbe. Ez hasznos bizonyos helyzetekben, amikor egy streamet a kód fogyaszt el, amelynek "vissza kell vennie" egy bizonyos mennyiségű adatot, amit optimistán kihúzott a forrásból, hogy az adatokat továbbadhassák egy másik félnek.

A stream.unshift(chunk) metódus nem hívható meg az esemény kibocsátása 'end' után, különben futási hiba keletkezik.

A gyakran használó fejlesztőknek stream.unshift() érdemes inkább áttérni a Transform stream használatára. További információért lásd a API for stream implementers szakaszt.

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

Ellentétben a push-tal, stream.unshift(chunk) nem szűnd meg az olvasási folyamatot azzal, hogy visszaállítja a stream belső olvasási állapotát. Ez váratlan eredményeket okozhat, ha readable.unshift() olvasás közben hívják (azaz egy _read implementáción belül, egy egyedi streamen). A hívás readable.unshift() után azonnali push-olással megfelelően visszaállítod az olvasási állapotot, azonban a legjobb egyszerűen elkerülni a hívást readable.unshift() olvasás közben.
wrap(ReadableStream)

Node.js 0.10 előtt a streamek nem valósították meg a teljes node:stream modul API-t, ahogy azt jelenleg definiálják. (További információért lásd Compatibility a segítséget.)

Ha egy régebbi Node.js könyvtárat használunk, amely eseményeket bocsát 'data' ki és csak tanácsadó szünetet használ, akkor readable.wrap() a módszer olyan Readable streamet hozhat létre, amely a régi streamet használja adatforrásként.

Ritkán lesz szükség a használatára readable.wrap() , de a módszert kényelmes módon szolgálták a régebbi Node.js alkalmazások és könyvtárak közötti interakcióhoz.

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

Örökölt metódusok

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket.

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

A EventEmitter aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n) vagy alapértelmezés szerint events.defaultMaxListenersértékre állít be.
pipe<T>(T, PipeOptions)
setMaxListeners(number)

Alapértelmezés szerint EventEmitters figyelmeztetést jelenít meg, ha egy adott eseményhez több mint 10 figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A emitter.setMaxListeners() metódus lehetővé teszi a korlát módosítását ehhez az adott EventEmitter példányhoz. Az érték beállítható Infinity (vagy 0) értékre, hogy korlátlan számú figyelőt jelöljön.

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
[captureRejectionSymbol](Error, string | symbol, any[])

A Symbol.for('nodejs.rejection') módszert akkor hívják el, ha ígéretelutasítás történik esemény kibocsátásakor, és captureRejections az emitterben engedélyezett. Lehetséges a events.captureRejectionSymbolSymbol.for('nodejs.rejection')helyett használni.

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.
  }
}

Konstruktor adatai

Readable(ReadableOptions<Readable>) 

new Readable(options?: ReadableOptions<Readable>)

Paraméterek

options

ReadableOptions<Readable>

Tulajdonság adatai

closed

A true kibocsátás után 'close' is kibocsátott.

closed: boolean

Tulajdonság értéke

boolean

destroyed

A true hívás után readable.destroy() történt.

destroyed: boolean

Tulajdonság értéke

boolean

errored

Hibát ad, ha a stream hibával megsemmisült.

errored: null | Error

Tulajdonság értéke

null | Error

readable

Ha true biztonságos a olvasás hívása, ami azt jelenti, hogy a stream nem sérült meg vagy nem bocsátott 'error' ki, vagy 'end'.

readable: boolean

Tulajdonság értéke

boolean

readableAborted

Visszaadja azt a reakciót, hogy a stream megsemmisült-e vagy hibázott az emitáció 'end'előtt.

readableAborted: boolean

Tulajdonság értéke

boolean

readableDidRead

Visszajelzés, hogy kibocsátották-e 'data' .

readableDidRead: boolean

Tulajdonság értéke

boolean

readableEncoding

Getter egy adott Readable áram tulajdonságáraencoding. A encoding tulajdonság a setEncoding módszerrel állítható be.

readableEncoding: null | BufferEncoding

Tulajdonság értéke

null | BufferEncoding

readableEnded

Akkor válik, true amikor 'end' az esemény kibocsátódik.

readableEnded: boolean

Tulajdonság értéke

boolean

readableFlowing

Ez a tulajdonság tükrözi a Readable patak aktuális állapotát, ahogy azt a Három állapot szakaszban leírjuk.

readableFlowing: null | boolean

Tulajdonság értéke

null | boolean

readableHighWaterMark

A passz értékét highWaterMark adja vissza, amikor ezt Readablelétrehozza.

readableHighWaterMark: number

Tulajdonság értéke

number

readableLength

Ez a tulajdonság tartalmazza a sorban lévő bájtok (vagy objektumok) számát, amelyek készen állnak az olvasásra. Az érték introspektív adatokat ad a . highWaterMarkállapotáról.

readableLength: number

Tulajdonság értéke

number

readableObjectMode

Getter egy adott Readable áram tulajdonságáraobjectMode.

readableObjectMode: boolean

Tulajdonság értéke

boolean

Metódus adatai

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

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)egyenértékű a .-nak.stream.compose(readable, s)

Ez a módszer lehetővé teszi egy AbortSignal adás biztosítását is, amely megszakítás esetén elpusztítja a keletkezett folyamot.

További információért lásd a stream.compose(...streams) jelű részt.

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

Paraméterek

stream

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

options

Abortable

Válaszok

Duplex

egy áramlat, amely az áramlattal streamáll össze.

destroy(Error)

Pusztítsd el a patakot. Opcionálisan kibocsáthatsz egy 'error' eseményt, és kibocsáthatsz egy 'close' eseményt (kivéve, ha emitClose beállított-a false). E hívás után az olvasható stream minden belső erőforrást felszabadít, és a következő hívásokat push() figyelmen kívül hagyják.

Ha destroy() behívták, további hívások no-op lesznek, és további hibák nem kerülhetnek ki, kivéve , _destroy() mint 'error'.

A végrehajtóknak nem szabad felülírniuk ezt a módszert, hanem inkább implementálniuk readable._destroy().

function destroy(error?: Error): Readable

Paraméterek

error

Error

Hiba, amely egy esetben hasznos terhelésként 'error' fog továbbítani

Válaszok

Readable

drop(number, Abortable)

Ez a módszer új streamet ad vissza, amelynek első limit chunkjai már az elejétől elhagyják.

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

Paraméterek

limit

number

hány darabot kell leejteni az olvashatóból.

options

Abortable

Válaszok

Readable

egy stream, amelynek limites szakaszai már az elejétől elmaradtak.

emit(string | symbol, any[]) 

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

Paraméterek

eventName

string | symbol

args

any[]

Válaszok

boolean

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

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

Paraméterek

eventName

E

args

ReadableEventMap[E]

Válaszok

boolean

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

Ez a módszer hasonló, és Array.prototype.every minden egyes darabon fn-t hív, hogy ellenőrizze, minden várt visszatérési érték igaz-e fn esetén. Ha egy fn hívás egy chunk awaited visszatérítési érték hamis, a stream megsemmisül, és az ígéret teljesül .false Ha az összes fn hívás a chunkokban igazságos értéket ad, az ígéret teljesül .true

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

Paraméterek

fn

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

egy függvény, amely az adatfolyam minden egyes részét megidézi. Aszinkron vagy sem.

options

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

Válaszok

Promise<boolean>

Egy ígéret, amely értékeli, true hogy az FN minden egyes darabért igazságos értéket adott vissza.

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

Ez a módszer lehetővé teszi az áramlat szűrését. Minden egyes darab esetén az fn függvényt hívják, és ha igazságos értéket ad vissza, akkor a chunk átkerül az eredményfolyamhoz. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül.

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

Paraméterek

fn

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

egy függvény, amely a streamből származó darabokat szűri. Aszinkron vagy sem.

options

ReadableOperatorOptions

Válaszok

Readable

egy fn predikátummal szűrt áramlat.

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>

Paraméterek

fn

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

options

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

Válaszok

Promise<any>

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

Ez a módszer hasonló a Array.prototype.findfn-hez minden egyes szakaszon, és fn-t hív, hogy megtaláljon egy chunkot, amelynek igazságértéke fn-hez. Ha egy fn hívás várt visszatérési értéke igaz, a stream megsemmisül, és az ígéret teljesül azzal az értékkel, amelyért a fn igazságos értéket adott vissza. Ha az összes fn hívás a chunkokra hamis értéket ad, az ígéret teljesül.undefined

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

Paraméterek

fn

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

egy függvény, amely az adatfolyam minden egyes részét megidézi. Aszinkron vagy sem.

options

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

Válaszok

Promise<undefined | T>

Egy ígéret, amely az első részhez értékelt, amelyhez az FN igazi értékkel értékelt, vagy undefined ha nem találtak elemet.

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

Ez a módszer új streamet ad vissza úgy, hogy a megadott visszahívást alkalmazza az áram egyes szakaszára, majd lapítja az eredményt.

Lehetséges egy streamet vagy más, iterable vagy asszinkron iterálható fn-ből visszaadni, és az eredmény folyamai összeolvadnak (lapítják) a visszaadott folyammal.

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

Paraméterek

fn

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

egy függvény, amely minden szakaszt leképez a folyamban. Lehet, hogy aszinkron. Lehet egy patak vagy generátor.

options

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

Válaszok

Readable

egy fn függvénnyel lapos leképezésű folyam.

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

Ez a módszer lehetővé teszi egy stream iterálását. Az áramfolyam minden egyes részéhez az fn függvény lesz meghívva. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül.

Ez a módszer eltér a for await...of hurkoktól, mivel opcionálisan egyszerre feldolgozhatja a darabokat. Ezen felül egy forEach iteráció csak akkor állíthat meg, ha egy signal opciót átsiklott, és megszakítja a kapcsolódó AbortControllert, miközben for await...of a megállítható returnvagy -vel break is megállítható. Mindkét esetben a patak tönkretelik.

Ez a módszer eltér az esemény meghallgatásától 'data' , mivel readable az eseményt használja az alatta lévő gépészetben, és korlátozhatja az egyidejű fn hívások számát.

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

Paraméterek

fn

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

egy függvény, amely az adatfolyam minden egyes részét megidézi. Aszinkron vagy sem.

options

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

Válaszok

Promise<void>

egy ígéret, amikor véget ér a stream.

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

Egy hasznos módszer Readable Streamek létrehozására iterátorokból.

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

Paraméterek

iterable

Iterable<any> | AsyncIterable<any>

Objektum implementálja az Symbol.asyncIterator vagy Symbol.iterator iterable protokollt. 'hiba' eseményt bocsát ki, ha null értéket passzolnak.

options

ReadableOptions<Readable>

Lehetőségek a new stream.Readable([options]). Alapértelmezés Readable.from()options.objectModetrueszerint , ha ezt kifejezetten ki nem állítjuk .options.objectModefalse

Válaszok

Readable

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

Egy hasznos módszer a webből ReadableStreamtörténő létrehozásáraReadable.

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

Paraméterek

readableStream

ReadableStream<any>

options

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

Válaszok

Readable

isDisturbed(ReadableStream<any> | ReadableStream)

Visszaadja azt is, hogy a streamet elolvasták vagy törölték.

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

Paraméterek

stream

ReadableStream<any> | ReadableStream

Válaszok

boolean

isPaused()

A readable.isPaused() módszer visszaadja a jelenlegi működési állapotot .Readable Ezt elsősorban a módszer mögött álló mechanizmus readable.pipe() használja. A legtöbb tipikus esetben nincs ok közvetlenül alkalmazni ezt a módszert.

const readable = new stream.Readable();

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

function isPaused(): boolean

Válaszok

boolean

iterator(ReadableIteratorOptions)

Ezzel a módszerrel létrehozott iterátor lehetőséget ad a felhasználóknak, hogy töröljék az áramfolyam megsemmisítését, ha a for await...of hurkot return, break, vagy throw, vagy az iterátor megsemmisíti, ha az áramlat hibát adott ki az iteráció során.

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

Paraméterek

options

ReadableIteratorOptions

Válaszok

AsyncIterator<any, undefined, any>

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

number

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

number

listeners(string | symbol) 

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

Paraméterek

eventName

string | symbol

Válaszok

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

listeners<E>(E) 

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

Paraméterek

eventName

E

Válaszok

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

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

Ez a módszer lehetővé teszi a padi leképezést az áramlat felett. Az fn függvényt minden egyes szakaszra hívják meg a streamben. Ha az fn függvény ígéretet ad vissza – az ígéret ed-re awaitkerül, mielőtt átadná az eredményfolyamnak.

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

Paraméterek

fn

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

egy függvény, amely minden szakaszt leképez a folyamban. Aszinkron vagy sem.

options

ReadableOperatorOptions

Válaszok

Readable

egy áramlat, amelyet az fn függvény képez le.

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

pause()

A readable.pause() módszer arra készteti, hogy egy áramlat áramlat megállítja az 'data' események kibocsátását, és kivált az áramlási módból. Bármilyen elérhetővé vált adat a belső pufferben marad.

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

A readable.pause() módszernek nincs hatása, ha van eseményhallgató 'readable' .

function pause(): Readable

Válaszok

Readable

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

push(any, BufferEncoding) 

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

Paraméterek

chunk

any

encoding

BufferEncoding

Válaszok

boolean

rawListeners(string | symbol) 

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

Paraméterek

eventName

string | symbol

Válaszok

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

rawListeners<E>(E) 

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

Paraméterek

eventName

E

Válaszok

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

read(number)

A readable.read() módszer kiolvassa az adatokat a belső pufferből, és visszaadja azokat. Ha nincs elérhető olvasható adat, null visszaküldik. Alapértelmezés szerint az adat objektumként kerül vissza Buffer , hacsak nem volt kódolás a readable.setEncoding() metódus segítségével, vagy az áramfolyam objektum módban működik.

Az opcionális size érv meghatározott számú bájtszámot határoz meg az olvasásra. Ha size a bájtok nem olvashatók, null akkor visszaküldik, hacsak az folyam nem ért véget, ekkor az összes belső pufferben maradt adat visszakerül.

Ha az size érv nincs megadva, az összes belső pufferben lévő adat visszakerül.

Az érvnek size kisebb vagy egyenlőnek kell lennie, mint 1 GiB.

A readable.read() módszert csak a szünetes módban működő streameken kell meghívni Readable . Áramlási módban readable.read() automatikusan hívják, amíg a belső puffer teljesen le nem merül.

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

Minden hívás readable.read() egy adatdarabot, vagyis nullvisszaad . A darabok nincsenek összekötve. A pufferben jelenleg lévő összes adat fogyasztásához hurokra van szükség while . Egy nagy fájl .read() olvasása esetén előfordulhat, hogy nullaz eddig minden pufferelt tartalmat elfogyasztotta, de még van még több adat, amelyet még nem puffereltek. Ebben az esetben új 'readable' esemény indul, amikor több adat van a pufferben. Végül az 'end' esemény akkor fog kibocsátásra kerülni, amikor már nincs több adat.

Ezért ahhoz, hogy egy fájl teljes tartalmát olvassuk az - readableről, több eseményre történő darabokat kell gyűjteni 'readable' :

const chunks = [];

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

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

Egy Readable objektum módban lévő stream mindig egyetlen elemet ad vissza egy hívásból , függetlenül readable.read(size)az size argumentus értékétől.

Ha a readable.read() módszer egy adatdarabot ad vissza, akkor egy 'data' esemény is kiemésztődik.

Az esemény kisugárzása után olvasott hívás 'end' visszatérnull. Futásidőben nem fog hiba felmerülni.

function read(size?: number): any

Paraméterek

size

number

Opcionális érv annak meghatározására, hogy mennyi adatot kell olvasni.

Válaszok

any

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

Ez a módszer sorrendben hívja meg a fn-t az áramfolyam minden egyes részén, és továbbítja neki az előző elem számításának eredményét. Ígéretet ad a redukció végső értékére.

Ha nem adunk ki kezdeti értéket, akkor az adatfolyam első darabját használják kiindulóként. Ha az áramlat üres, az ígéret a TypeErrorERR_INVALID_ARGS kód tulajdonsággal együtt elutasítódik.

A reduktorfüggvény elemenként iterálja az áramlatot, ami azt jelenti, hogy nincs egyidejű paraméter vagy párhuzamosság. A redukció egyidejű végrehajtásához az aszinkron függvényt kihúzhatod a readable.map metódushoz.

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

Paraméterek

fn

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

egy redukáló függvény, amely minden darabot áthív a folyamban. Aszinkron vagy sem.

Válaszok

Promise<T>

ígéret a redukció végső értékére.

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

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

Paraméterek

fn

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

initial

T

options

Abortable

Válaszok

Promise<T>

removeAllListeners(string | symbol) 

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

Paraméterek

eventName

string | symbol

Válaszok

Readable

removeAllListeners<E>(E) 

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

Paraméterek

eventName

E

Válaszok

Readable

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

Readable

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

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

Paraméterek

eventName

E

listener

(args: ReadableEventMap[E]) => void

Válaszok

Readable

resume()

A readable.resume() módszer egy explicit szünetelt Readable folyamot indít újra, hogy az emitációs 'data' események folytassa, így az áramlat áramlási módba vált.

A readable.resume() módszer felhasználható arra, hogy teljes mértékben felhasználja az adatfolyamot anélkül, hogy tényleges feldolgozná ezeket az adatokat:

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

A readable.resume() módszernek nincs hatása, ha van eseményhallgató 'readable' .

function resume(): Readable

Válaszok

Readable

setEncoding(BufferEncoding)

A readable.setEncoding() módszer beállítja a karakterkódolást az adatfolyamból olvasott Readable adatokhoz.

Alapértelmezés szerint nem rendelnek hozzá kódolást, és az adatfolyam adatai objektumként Buffer kerülnek vissza. Kódolás beállítása miatt az adatfolyam adatai a megadott kódolás stringjeiként térnek vissza, nem objektumként Buffer . Például a hívás readable.setEncoding('utf8') esetén a kimeneti adatokat UTF-8 adatként értelmezik, és stringként továbbítják. A hívás readable.setEncoding('hex') esetén az adat hexadecimális string formátumban kódolódik.

Az Readable áramlat megfelelően kezeli a többbájtos karaktereket, amelyeket az áramlaton keresztül továbbítanak, és egyébként rosszul dekódolnának, ha csak objektumként húznák ki őket.Buffer

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

Paraméterek

encoding

BufferEncoding

A használni kívánt kódolás.

Válaszok

Readable

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

Ez a módszer hasonló és Array.prototype.somefn-t hív minden darabra a folyamban, amíg a várt visszatérés értéke (vagy bármely igazságos érték) nem lesz true (vagy bármely igazságos érték). Ha egy fn hívás egy chunk awaited visszatérési értéken igaz, a stream megsemmisül, és az ígéret teljesül .true Ha a fn hívások egyike sem ad igazságos értéket, az ígéret teljesít .false

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

Paraméterek

fn

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

egy függvény, amely az adatfolyam minden egyes részét megidézi. Aszinkron vagy sem.

options

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

Válaszok

Promise<boolean>

Egy ígéret, amely értékeli, true hogy az FN legalább az egyik darab értékét adta-e vissza.

take(number, Abortable)

Ez a módszer egy új adatfolyamot ad vissza az első limit chunkokkal.

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

Paraméterek

limit

number

hány darabot kell kivenni az olvashatóból.

options

Abortable

Válaszok

Readable

egy stream, ahol limit részeket vesznek.

toArray(Abortable)

Ez a módszer lehetővé teszi, hogy könnyen megszerezzék egy folyam tartalmát.

Mivel ez a módszer az egész streamet olvassa be a memóriába, semlegesíti az áramlatok előnyeit. Ez az interoperabilitásra és a kényelmi megoldásra van szánva, nem pedig az elsődleges módnak a streamek fogyasztásának.

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

Paraméterek

options

Abortable

Válaszok

Promise<any[]>

egy ígéret, amely tartalmaz egy tömböt az áramlat tartalmával.

toWeb(ReadableStream, ReadableToWebOptions)

Egy hasznos módszer egy webet ReadableStream létrehozni egy Readable.

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

Paraméterek

streamReadable

ReadableStream

options

ReadableToWebOptions

Válaszok

ReadableStream<any>

unpipe(WritableStream)

A readable.unpipe() módszer leválasztja a Writable korábban csatlakoztatott víz vízvezeték-módszert.

Ha destination nincs megadva, akkor minden cső leválik.

Ha destination meg van határozva, de nincs beállítva cső rá, akkor a módszer semmit sem csinál.

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

Paraméterek

destination

WritableStream

Opcionálisan specifikus áram a kihúzható

Válaszok

Readable

unshift(any, BufferEncoding)

Jelként továbbítva chunknull az áramlat végét (EOF), és úgy viselkedik, mint readable.push(null), utána több adat nem írható ki. Az EOF jelet a puffer végén helyezzük, és a pufferelt adatok továbbra is elöblíthetők.

A readable.unshift() módszer egy adattömböt visszatol a belső pufferbe. Ez hasznos bizonyos helyzetekben, amikor egy streamet a kód fogyaszt el, amelynek "vissza kell vennie" egy bizonyos mennyiségű adatot, amit optimistán kihúzott a forrásból, hogy az adatokat továbbadhassák egy másik félnek.

A stream.unshift(chunk) metódus nem hívható meg az esemény kibocsátása 'end' után, különben futási hiba keletkezik.

A gyakran használó fejlesztőknek stream.unshift() érdemes inkább áttérni a Transform stream használatára. További információért lásd a API for stream implementers szakaszt.

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

Ellentétben a push-tal, stream.unshift(chunk) nem szűnd meg az olvasási folyamatot azzal, hogy visszaállítja a stream belső olvasási állapotát. Ez váratlan eredményeket okozhat, ha readable.unshift() olvasás közben hívják (azaz egy _read implementáción belül, egy egyedi streamen). A hívás readable.unshift() után azonnali push-olással megfelelően visszaállítod az olvasási állapotot, azonban a legjobb egyszerűen elkerülni a hívást readable.unshift() olvasás közben.

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

Paraméterek

chunk

any

Egy adatdarab, amit vissza kell kapcsolni az olvasási sorba. Objektum módban nem működő streamek esetén chunk {string}, {Buffer}, {TypedArray}, {DataView} vagy null. Objektummód folyamok chunk esetén bármilyen JavaScript érték lehet.

encoding

BufferEncoding

A string chunkok kódolása. Érvényes Buffer kódolásnak kell lennie, például 'utf8' vagy 'ascii'.

wrap(ReadableStream)

Node.js 0.10 előtt a streamek nem valósították meg a teljes node:stream modul API-t, ahogy azt jelenleg definiálják. (További információért lásd Compatibility a segítséget.)

Ha egy régebbi Node.js könyvtárat használunk, amely eseményeket bocsát 'data' ki és csak tanácsadó szünetet használ, akkor readable.wrap() a módszer olyan Readable streamet hozhat létre, amely a régi streamet használja adatforrásként.

Ritkán lesz szükség a használatára readable.wrap() , de a módszert kényelmes módon szolgálták a régebbi Node.js alkalmazások és könyvtárak közötti interakcióhoz.

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

Paraméterek

stream

ReadableStream

Egy "régi stílusú" olvasható stream

Válaszok

Readable

[asyncIterator]() 

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

Válaszok

AsyncIterator<any, undefined, any>

AsyncIterator hogy teljesen elfogyasztsák a patakot.

Örökölt metódus részletei

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket.

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

Válaszok

(string | symbol)[]

Örökölt Stream.eventNames

getMaxListeners()

A EventEmitter aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n) vagy alapértelmezés szerint events.defaultMaxListenersértékre állít be.

function getMaxListeners(): number

Válaszok

number

Örökölt Stream.getMaxListeners

pipe<T>(T, PipeOptions) 

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

Paraméterek

destination

T

options

PipeOptions

Válaszok

T

Örökölt Stream.pipe

setMaxListeners(number)

Alapértelmezés szerint EventEmitters figyelmeztetést jelenít meg, ha egy adott eseményhez több mint 10 figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A emitter.setMaxListeners() metódus lehetővé teszi a korlát módosítását ehhez az adott EventEmitter példányhoz. Az érték beállítható Infinity (vagy 0) értékre, hogy korlátlan számú figyelőt jelöljön.

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

function setMaxListeners(n: number): Readable

Paraméterek

n

number

Válaszok

Readable

Örökölt Stream.setMaxListeners

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

A Symbol.for('nodejs.rejection') módszert akkor hívják el, ha ígéretelutasítás történik esemény kibocsátásakor, és captureRejections az emitterben engedélyezett. Lehetséges a events.captureRejectionSymbolSymbol.for('nodejs.rejection')helyett használni.

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

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

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

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

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

Paraméterek

error

Error

event

string | symbol

args

any[]

Örökölt Stream.__@captureRejectionSymbol@175