Readable interface

Pakiet:
@azure/storage-common
Rozszerzenie

Stream

Właściwości

closed

Po true'close' emisji jest już wyemitowany.
destroyed

To true po readable.destroy() tym, co zostało wezwane.
errored

Zwraca błąd, jeśli strumień został zniszczony błędem.
readable

Jest true to, czy bezpiecznie jest wywołać odczyt, co oznacza, że strumień nie został zniszczony ani emitowany 'error' lub 'end'.
readableAborted

Zwraca, czy strumień został zniszczony lub wprowadzony błąd przed emisją 'end'.
readableDidRead

Zwraca się, czy 'data' został wyemitowany.
readableEncoding

Getter dla własności encoding danego Readable strumienia. Właściwość tę encoding można ustawić za pomocą metody setEncoded .
readableEnded

Staje się true , gdy 'end' wydawane jest zdarzenie.
readableFlowing

Ta własność odzwierciedla obecny stan strumienia Readable opisany w sekcji Trzy stany .
readableHighWaterMark

Zwraca wartość przekazanej podczas highWaterMark tworzenia tego Readable.
readableLength

Ta właściwość zawiera liczbę bajtów (lub obiektów) w kolejce gotowych do odczytu. Wartość ta dostarcza danych introspekcyjnych dotyczących statusu .highWaterMark
readableObjectMode

Getter dla własności objectMode danego Readable strumienia.

Metody

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

Alias dla elementu emitter.on(eventName, listener).
compose(WritableStream | WritableStream | TransformStream | (source: any) => void, Abortable) 
import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']

readable.compose(s) jest równoważne z stream.compose(readable, s).

Ta metoda pozwala również na dostosowanie strumienia AbortSignal , który zniszczy złożony strumień po przerwaniu.

Aby uzyskać więcej informacji, zobacz stream.compose(...streams).
destroy(Error)

Zniszczyć strumień. Opcjonalnie wyemituj 'error' zdarzenie, a następnie wyemituje zdarzenie 'close' (chyba że emitClose jest ustawione na false). Po tym wywołaniu czytelny strumień zwolni wszelkie wewnętrzne zasoby, a kolejne wezwania push() zostaną zignorowane.

Po destroy() wywołaniu wszelkie kolejne wywołania będą no-op i nie pojawią się żadne kolejne błędy poza , _destroy() które mogą być emitowane jako .'error'

Implementatorzy nie powinni nadpisywać tej metody, lecz zamiast tego implementować readable._destroy().
drop(number, Abortable)

Ta metoda zwraca nowy strumień z pierwszymi blokami limitu odrzucone od początku.
emit(string | symbol, any[])
emit<E>(E, ReadableEventMap[E])

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Ta metoda jest podobna do Array.prototype.every i wywołuje fn na każdym chunku w strumieniu, aby sprawdzić, czy wszystkie oczekiwane wartości zwrotne są prawdziwe dla fn. Gdy wywołanie fn na wartości zwrotu bloku awaitjest fałszywe, strumień zostaje zniszczony, a obietnica spełniona przez false. Jeśli wszystkie wywołania fn na blokach zwracają wartość prawdziwą, obietnica jest spełniona przez true.
filter((data: any, options?: Abortable) => boolean | Promise<boolean>, ReadableOperatorOptions)

Ta metoda pozwala na filtrowanie strumienia. Dla każdego fragmentu strumienia wywołana zostanie funkcja fn i jeśli zwróci wartość prawdziwą, fragment zostanie przekazany do strumienia wyniku. Jeśli funkcja fn zwraca obietnicę – ta obietnica będzie ed await.
find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)
find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Ta metoda jest podobna do Array.prototype.find i wywołuje fn na każdym chunku w strumieniu, aby znaleźć chunk z prawdziwą wartością fn. Gdy oczekiwana wartość zwrotu wywołania fn jest prawdziwa, strumień zostaje zniszczony, a obietnica spełniona z wartością, dla której fn zwrócił wartość prawdziwą. Jeśli wszystkie wywołania fn na blokach zwracają fałszywą wartość, obietnica jest spełniona przez undefined.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Ta metoda zwraca nowy strumień poprzez zastosowanie danego callbacku do każdego fragmentu strumienia, a następnie spłaszczenie wyniku.

Możliwe jest zwrócenie strumienia lub innego iterowalnego lub asynchronicznego iterowalnego z fn i strumienie wynikowe zostaną połączone (spłaszczone) z zwróconym strumieniem.
forEach((data: any, options?: Abortable) => void | Promise<void>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Ta metoda pozwala na iterację strumienia. Dla każdego chunku w strumieniu wywołana zostanie funkcja fn . Jeśli funkcja fn zwraca obietnicę – ta obietnica będzie ed await.

Ta metoda różni się od for await...of pętli tym, że opcjonalnie może przetwarzać fragmenty równocześnie. Ponadto iterację forEach można zatrzymać tylko po przejściu opcji signal i przerwaniu powiązanego AbortControllera, podczas gdy for await...of można ją zatrzymać za break pomocą lub return. W obu przypadkach strumień zostanie zniszczony.

Ta metoda różni się od odsłuchu 'data' zdarzenia tym, że wykorzystuje zdarzenie readable w maszynie podstawowej i może ograniczyć liczbę jednoczesnych wywołań fn .
isPaused()

Metoda readable.isPaused() zwraca aktualny stan pracy .Readable Jest to wykorzystywane głównie przez mechanizm, który leży u podstaw tej metody readable.pipe() . W większości typowych przypadków nie ma powodu, by stosować tę metodę bezpośrednio.

const readable = new stream.Readable();

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

Iterator utworzony tą metodą daje użytkownikom możliwość anulowania zniszczenia strumienia, jeśli pętla for await...of zostanie zakończona przez return, break, lub throw, lub jeśli iterator zniszczy strumień w przypadku błędu podczas iteracji.
listenerCount(string | symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.
listeners(string | symbol)
listeners<E>(E)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
map((data: any, options?: Abortable) => any, ReadableOperatorOptions)

Ta metoda pozwala na mapowanie strumienia. Funkcja fn będzie wywoływana dla każdego chunku w strumieniu. Jeśli funkcja fn zwraca obietnicę – ta obietnica zostanie ed awaitprzed przekazaniem do strumienia wyników.
off(string | symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)

Alias dla elementu emitter.removeListener().
on(string | symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
once(string | symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
pause()

Metoda ta readable.pause() powoduje, że strumień w trybie przepływu przestaje emitować 'data' zdarzenia, przełączając się z trybu przepływu. Wszelkie dostępne dane pozostaną w buforze wewnętrznym.

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

Metoda nie readable.pause() ma efektu, jeśli istnieje 'readable' słuchacz zdarzeń.
prependListener(string | symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
prependOnceListener(string | symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
push(any, BufferEncoding)
rawListeners(string | symbol)
rawListeners<E>(E)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
read(number)

Metoda readable.read() odczytuje dane z wewnętrznego bufora i zwraca je. Jeśli nie ma dostępnych danych do odczytu, null zwraca się. Domyślnie dane są zwracane jako obiekt, Buffer chyba że kodowanie zostało określone metodą readable.setEncoding() lub strumień działa w trybie obiektowym.

Argument opcjonalny size określa określoną liczbę bajtów do odczytu. Jeśli size bajty nie są dostępne do odczytu, zostaną zwrócone, nullchyba że strumień się zakończył, wtedy wszystkie dane pozostały w buforze wewnętrznym zostaną zwrócone.

Jeśli size argument nie zostanie określony, wszystkie dane zawarte w wewnętrznym buforze zostaną zwrócone.

Argument size musi być mniejszy lub równy 1 GiB.

Metoda powinna readable.read() być wywoływana tylko w strumieniach Readable działających w trybie pauzy. W trybie przepływu jest wywoływany automatycznie, readable.read() aż wewnętrzny bufor zostanie całkowicie opróżniony.

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

Każde wywołanie zwraca readable.read() fragment danych, czyli null. Fragmenty nie są połączone. Pętla jest konieczna, aby zużyć wszystkie dane obecnie znajdujące while się w buforze. Podczas odczytu dużego pliku .read() może się zwrócić null, po zużyciu całej dotychczas zbuforowanej zawartości, ale wciąż jest więcej danych, które nie są jeszcze buforowane. W takim przypadku nowe 'readable' zdarzenie zostanie wygenerowane, gdy w buforze pojawi się więcej danych. Na koniec 'end' wydarzenie zostanie wyemitowane, gdy nie będzie już więcej danych.

Dlatego aby odczytać całą zawartość pliku z , readablekonieczne jest zebranie fragmentów przez wiele 'readable' zdarzeń:

const chunks = [];

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

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

Strumień Readable w trybie obiektowym zawsze zwraca pojedynczy element z wywołania do readable.read(size), niezależnie od wartości argumentu size .

Jeśli readable.read() metoda zwraca fragment danych, zostanie również wygenerowane zdarzenie 'data' .

Wezwanie do odczytu po 'end' emisji zdarzenia wróci null. Nie pojawi się żaden błąd w czasie działania.
reduce<T>((previous: any, data: any, options?: Abortable) => T)

Ta metoda wywołuje fn na każdym fragmencie strumienia w kolejności, przekazując mu wynik z obliczeń na poprzednim elemencie. Zwraca obietnicę końcowej wartości redukcji.

Jeśli nie podano wartości początkowej , jako wartość początkową używa się pierwszego fragmentu strumienia. Jeśli strumień jest pusty, obietnica jest odrzucana z TypeError właściwością z ERR_INVALID_ARGS kodem.

Funkcja reduktora iteruje strumień element po elemencie, co oznacza, że nie ma parametru współbieżności ani równoległości. Aby jednocześnie wykonać redukcję, możesz wyodrębnić funkcję asynchroniczną do readable.map metody.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string | symbol)
removeAllListeners<E>(E)

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
removeListener(string | symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wywołania removeListener() lub removeAllListeners() emisji i przed zakończeniem wykonania przez ostatniego słuchacza nie usuną ich z emit() trwających. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Ponieważ słuchacze są zarządzane za pomocą wewnętrznej tablicy, wywołanie tego zmienia indeksy pozycji każdego słuchacza zarejestrowanego po usunięciu tego nasłuchu. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
resume()

Metoda ta readable.resume() powoduje, że wyraźnie wstrzymany Readable strumień wznawia emisję 'data' zdarzeń, przełączając strumień w tryb przepływu.

Metoda ta readable.resume() może być użyta do pełnego wykorzystania danych ze strumienia bez faktycznego przetwarzania tych danych:

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

Metoda nie readable.resume() ma efektu, jeśli istnieje 'readable' słuchacz zdarzeń.
setEncoding(BufferEncoding)

Metoda ta readable.setEncoding() ustawia kodowanie znaków dla danych odczytanych Readable ze strumienia.

Domyślnie nie przypisuje się kodowania, a dane strumieniowe są zwracane jako Buffer obiekty. Ustawienie kodowania powoduje, że dane strumieniowe są zwracane jako ciągi znaków określonych kodów, a nie jako Buffer obiekty. Na przykład wywołanie readable.setEncoding('utf8') powoduje, że dane wyjściowe są interpretowane jako dane UTF-8 i przekazywane jako ciągi znaków. Wywołanie readable.setEncoding('hex') spowoduje zakodowanie danych w formacie szesnastkowego ciągu tekstowego.

Strumień Readable będzie prawidłowo obsługiwał znaki wielobajtowe dostarczane przez strumień, które w przeciwnym razie zostałyby niepoprawnie zdekodowane, gdyby zostały po prostu pobrane ze strumienia jako Buffer obiekty.

const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
  assert.equal(typeof chunk, 'string');
  console.log('Got %d characters of string data:', chunk.length);
});
some((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Ta metoda jest podobna do Array.prototype.some i wywołuje fn na każdym bloku strumienia, aż oczekiwana wartość zwrotu jest ( true lub dowolna wartość prawdziwa). Gdy wywołanie fn na wartości zwrotu chunk awaited jest prawdziwe, strumień zostaje zniszczony, a obietnica spełniona z .true Jeśli żadne z wywołań fn na blokach nie zwraca wartości prawdziwej, obietnica zostaje spełniona przez .false
take(number, Abortable)

Ta metoda zwraca nowy strumień z pierwszymi blokami limitu .
toArray(Abortable)

Ta metoda pozwala łatwo uzyskać zawartość strumienia.

Ponieważ ta metoda odczytuje cały strumień do pamięci, niweluje korzyści płynące ze strumieni. Jest przeznaczony dla interoperacyjności i wygody, a nie jako główny sposób konsumowania strumieni.
unpipe(WritableStream)

Metoda ta readable.unpipe() odłącza strumień wcześniej przymocowany Writable metodą rur.

Jeśli nie destination jest to określone, wszystkie rury są odłączane.

Jeśli jest destination określona, ale nie jest dla niej ustawiona żadna rura, to metoda nic nie robi.

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)

Przechodząc chunk jako null sygnalizuje koniec strumienia (EOF) i zachowuje się tak samo jak readable.push(null), po czym nie można już zapisać żadnych danych. Sygnał EOF jest umieszczany na końcu bufora, a wszystkie zbuforowane dane nadal są wypłukiwane.

Metoda ta readable.unshift() wsuwa fragment danych z powrotem do wewnętrznego bufora. Jest to przydatne w pewnych sytuacjach, gdy strumień jest konsumowany przez kod, który musi "odkonsumować" pewną ilość danych, które optymistycznym wyciągnął ze źródła, aby dane mogły zostać przekazane innej osobie.

Metoda nie stream.unshift(chunk) może być wywołana po 'end' wygenerowaniu zdarzenia, ponieważ w trakcie wykonywania zostanie wygenerowany błąd.

Programiści często korzystający powinni stream.unshift() rozważyć przejście na stream Transform zamiast tego. Zobacz sekcję API for stream implementers , aby uzyskać więcej informacji.

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

W przeciwieństwie do push, nie zakończy stream.unshift(chunk) procesu odczytu przez resetowanie wewnętrznego stanu odczytu strumienia. Może to powodować nieoczekiwane wyniki, jeśli readable.unshift() jest wywołany podczas odczytu (czyli z _read implementacji na niestandardowym strumieniu). readable.unshift() do wywołania zresetuje stan odczytu odpowiednio, jednak najlepiej unikać wywołań readable.unshift() podczas wykonywania odczytu.
wrap(ReadableStream)

Przed Node.js 0.10 strumienie nie implementowały całego node:stream API modułu w obecnej formie. (Zobacz więcej Compatibility informacji.)

Korzystając ze starszej biblioteki Node.js, która generuje 'data' zdarzenia i ma metodę pauzy działającą wyłącznie doradczo, metoda ta readable.wrap() może być użyta do stworzenia strumienia Readable wykorzystującego stary strumień jako źródło danych.

Rzadko będzie konieczna do użycia readable.wrap() , ale metoda ta została udostępniona jako wygoda do interakcji ze starszymi aplikacjami Node.js i bibliotekami.

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

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

Dzwoni readable.destroy() z an AbortError i zwraca obietnicę, która spełnia się po zakończeniu streamu.
[asyncIterator]()
[toAsyncStreamable]()

Po włączeniu flagi --experimental-stream-iter strumienie implementują protokółReadable, Stream.toAsyncStreamable umożliwiając efektywne konsumpcje stream/iter przez API.

Zapewnia to partiowy asynchroniczny iterator, który odprowadza wstrzymek strumienia na Uint8Array[] partie, amortyzując narzut Promise na jeden fragment ścieżki standardowej Symbol.asyncIterator . W strumieniach bajtów fragmenty są bezpośrednio wydawane jako Buffer instancje (które są Uint8Array podklasami). Dla strumieni obiektowych lub kodowanych każdy fragment jest normalizowany do przed Uint8Array wsadowaniem.

Zwrócony iterator jest oznaczony jako zweryfikowane źródło, więc from() przekazuje go bez dodatkowej normalizacji.

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'

Bez flagi --experimental-stream-iter , wywołanie tej metody rzuca ERR_STREAM_ITER_MISSING_FLAG.

Metody dziedziczone

eventNames()

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki.

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

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie ma wartość events.defaultMaxListeners.
pipe<T>(T, PipeOptions)
setMaxListeners(number)

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
[captureRejectionSymbol](Error, string | symbol, any[])

Metoda ta Symbol.for('nodejs.rejection') jest wywoływana w przypadku, gdy podczas emisji zdarzenia następuje odrzucenie obietnicy i captureRejections jest włączona na emiterze. Można użyć events.captureRejectionSymbol go zamiast .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.
  }
}

Szczegóły właściwości

closed

Po true'close' emisji jest już wyemitowany.

closed: boolean

Wartość właściwości

boolean

destroyed

To true po readable.destroy() tym, co zostało wezwane.

destroyed: boolean

Wartość właściwości

boolean

errored

Zwraca błąd, jeśli strumień został zniszczony błędem.

errored: Error | null

Wartość właściwości

Error | null

readable

Jest true to, czy bezpiecznie jest wywołać odczyt, co oznacza, że strumień nie został zniszczony ani emitowany 'error' lub 'end'.

readable: boolean

Wartość właściwości

boolean

readableAborted

Zwraca, czy strumień został zniszczony lub wprowadzony błąd przed emisją 'end'.

readableAborted: boolean

Wartość właściwości

boolean

readableDidRead

Zwraca się, czy 'data' został wyemitowany.

readableDidRead: boolean

Wartość właściwości

boolean

readableEncoding

Getter dla własności encoding danego Readable strumienia. Właściwość tę encoding można ustawić za pomocą metody setEncoded .

readableEncoding: BufferEncoding | null

Wartość właściwości

BufferEncoding | null

readableEnded

Staje się true , gdy 'end' wydawane jest zdarzenie.

readableEnded: boolean

Wartość właściwości

boolean

readableFlowing

Ta własność odzwierciedla obecny stan strumienia Readable opisany w sekcji Trzy stany .

readableFlowing: boolean | null

Wartość właściwości

boolean | null

readableHighWaterMark

Zwraca wartość przekazanej podczas highWaterMark tworzenia tego Readable.

readableHighWaterMark: number

Wartość właściwości

number

readableLength

Ta właściwość zawiera liczbę bajtów (lub obiektów) w kolejce gotowych do odczytu. Wartość ta dostarcza danych introspekcyjnych dotyczących statusu .highWaterMark

readableLength: number

Wartość właściwości

number

readableObjectMode

Getter dla własności objectMode danego Readable strumienia.

readableObjectMode: boolean

Wartość właściwości

boolean

Szczegóły metody

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Alias dla elementu emitter.on(eventName, listener).

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

Parametry

eventName

E

listener

(args: ReadableEventMap[E]) => void

Zwraca

this

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

import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']

readable.compose(s) jest równoważne z stream.compose(readable, s).

Ta metoda pozwala również na dostosowanie strumienia AbortSignal , który zniszczy złożony strumień po przerwaniu.

Aby uzyskać więcej informacji, zobacz stream.compose(...streams).

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

Parametry

stream

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

options

Abortable

Zwraca

Duplex

strumień złożony ze strumienia stream.

destroy(Error)

Zniszczyć strumień. Opcjonalnie wyemituj 'error' zdarzenie, a następnie wyemituje zdarzenie 'close' (chyba że emitClose jest ustawione na false). Po tym wywołaniu czytelny strumień zwolni wszelkie wewnętrzne zasoby, a kolejne wezwania push() zostaną zignorowane.

Po destroy() wywołaniu wszelkie kolejne wywołania będą no-op i nie pojawią się żadne kolejne błędy poza , _destroy() które mogą być emitowane jako .'error'

Implementatorzy nie powinni nadpisywać tej metody, lecz zamiast tego implementować readable._destroy().

function destroy(error?: Error): this

Parametry

error

Error

Błąd, który zostanie przekazany jako ładunek w zdarzeniu 'error'

Zwraca

this

drop(number, Abortable)

Ta metoda zwraca nowy strumień z pierwszymi blokami limitu odrzucone od początku.

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

Parametry

limit

number

Liczba fragmentów, które trzeba usunąć z czytelnego.

options

Abortable

Zwraca

Readable

strumień z limitem bloków odrzucanych od początku.

emit(string | symbol, any[]) 

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

Parametry

eventName

string | symbol

args

any[]

Zwraca

boolean

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

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

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

Parametry

eventName

E

args

ReadableEventMap[E]

Zwraca

boolean

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

Ta metoda jest podobna do Array.prototype.every i wywołuje fn na każdym chunku w strumieniu, aby sprawdzić, czy wszystkie oczekiwane wartości zwrotne są prawdziwe dla fn. Gdy wywołanie fn na wartości zwrotu bloku awaitjest fałszywe, strumień zostaje zniszczony, a obietnica spełniona przez false. Jeśli wszystkie wywołania fn na blokach zwracają wartość prawdziwą, obietnica jest spełniona przez true.

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

Parametry

fn

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

funkcja wywołująca każdy fragment strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

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

Zwraca

Promise<boolean>

Obietnica oceniająca na , true czy fn zwraca prawdziwą wartość dla każdego z bloków.

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

Ta metoda pozwala na filtrowanie strumienia. Dla każdego fragmentu strumienia wywołana zostanie funkcja fn i jeśli zwróci wartość prawdziwą, fragment zostanie przekazany do strumienia wyniku. Jeśli funkcja fn zwraca obietnicę – ta obietnica będzie ed await.

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

Parametry

fn

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

funkcja filtrująca fragmenty strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

ReadableOperatorOptions

Zwraca

Readable

strumień filtrowany predykatem fn.

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

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

Parametry

fn

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

options

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

Zwraca

Promise<any>

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

Ta metoda jest podobna do Array.prototype.find i wywołuje fn na każdym chunku w strumieniu, aby znaleźć chunk z prawdziwą wartością fn. Gdy oczekiwana wartość zwrotu wywołania fn jest prawdziwa, strumień zostaje zniszczony, a obietnica spełniona z wartością, dla której fn zwrócił wartość prawdziwą. Jeśli wszystkie wywołania fn na blokach zwracają fałszywą wartość, obietnica jest spełniona przez undefined.

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

Parametry

fn

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

funkcja wywołująca każdy fragment strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

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

Zwraca

Promise<T | undefined>

Obietnica wyliczająca się do pierwszego fragmentu, dla którego fn ocenił wartość prawdziwą, lub undefined jeśli nie znaleziono żadnego elementu.

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

Ta metoda zwraca nowy strumień poprzez zastosowanie danego callbacku do każdego fragmentu strumienia, a następnie spłaszczenie wyniku.

Możliwe jest zwrócenie strumienia lub innego iterowalnego lub asynchronicznego iterowalnego z fn i strumienie wynikowe zostaną połączone (spłaszczone) z zwróconym strumieniem.

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

Parametry

fn

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

funkcja mapująca na każdy fragment strumienia. Może być asynchroniczna. Może to strumień lub generator.

options

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

Zwraca

Readable

strumień płaski odwzorowany funkcją fn.

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

Ta metoda pozwala na iterację strumienia. Dla każdego chunku w strumieniu wywołana zostanie funkcja fn . Jeśli funkcja fn zwraca obietnicę – ta obietnica będzie ed await.

Ta metoda różni się od for await...of pętli tym, że opcjonalnie może przetwarzać fragmenty równocześnie. Ponadto iterację forEach można zatrzymać tylko po przejściu opcji signal i przerwaniu powiązanego AbortControllera, podczas gdy for await...of można ją zatrzymać za break pomocą lub return. W obu przypadkach strumień zostanie zniszczony.

Ta metoda różni się od odsłuchu 'data' zdarzenia tym, że wykorzystuje zdarzenie readable w maszynie podstawowej i może ograniczyć liczbę jednoczesnych wywołań fn .

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

Parametry

fn

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

funkcja wywołująca każdy fragment strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

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

Zwraca

Promise<void>

Obietnica na zakończenie streamu.

isPaused()

Metoda readable.isPaused() zwraca aktualny stan pracy .Readable Jest to wykorzystywane głównie przez mechanizm, który leży u podstaw tej metody readable.pipe() . W większości typowych przypadków nie ma powodu, by stosować tę metodę bezpośrednio.

const readable = new stream.Readable();

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

function isPaused(): boolean

Zwraca

boolean

iterator(ReadableIteratorOptions)

Iterator utworzony tą metodą daje użytkownikom możliwość anulowania zniszczenia strumienia, jeśli pętla for await...of zostanie zakończona przez return, break, lub throw, lub jeśli iterator zniszczy strumień w przypadku błędu podczas iteracji.

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

Parametry

options

ReadableIteratorOptions

Zwraca

AsyncIterator<any>

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

number

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

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.

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

Parametry

eventName

E

Nazwa zdarzenia, dla których jest nasłuchiwane

listener

(args: ReadableEventMap[E]) => void

Funkcja obsługi zdarzeń

Zwraca

number

listeners(string | symbol) 

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

Parametry

eventName

string | symbol

Zwraca

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

listeners<E>(E)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

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

Parametry

eventName

E

Zwraca

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

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

Ta metoda pozwala na mapowanie strumienia. Funkcja fn będzie wywoływana dla każdego chunku w strumieniu. Jeśli funkcja fn zwraca obietnicę – ta obietnica zostanie ed awaitprzed przekazaniem do strumienia wyników.

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

Parametry

fn

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

funkcja mapująca na każdy fragment strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

ReadableOperatorOptions

Zwraca

Readable

strumień mapowany funkcją fn.

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Alias dla elementu emitter.removeListener().

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

Parametry

eventName

E

listener

(args: ReadableEventMap[E]) => void

Zwraca

this

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parametry

eventName

E

Nazwa zdarzenia.

listener

(args: ReadableEventMap[E]) => void

Funkcja wywołania zwrotnego

Zwraca

this

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parametry

eventName

E

Nazwa zdarzenia.

listener

(args: ReadableEventMap[E]) => void

Funkcja wywołania zwrotnego

Zwraca

this

pause()

Metoda ta readable.pause() powoduje, że strumień w trybie przepływu przestaje emitować 'data' zdarzenia, przełączając się z trybu przepływu. Wszelkie dostępne dane pozostaną w buforze wewnętrznym.

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

Metoda nie readable.pause() ma efektu, jeśli istnieje 'readable' słuchacz zdarzeń.

function pause(): this

Zwraca

this

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

E

Nazwa zdarzenia.

listener

(args: ReadableEventMap[E]) => void

Funkcja wywołania zwrotnego

Zwraca

this

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

E

Nazwa zdarzenia.

listener

(args: ReadableEventMap[E]) => void

Funkcja wywołania zwrotnego

Zwraca

this

push(any, BufferEncoding) 

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

Parametry

chunk

any

encoding

BufferEncoding

Zwraca

boolean

rawListeners(string | symbol) 

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

Parametry

eventName

string | symbol

Zwraca

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

rawListeners<E>(E)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

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

Parametry

eventName

E

Zwraca

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

read(number)

Metoda readable.read() odczytuje dane z wewnętrznego bufora i zwraca je. Jeśli nie ma dostępnych danych do odczytu, null zwraca się. Domyślnie dane są zwracane jako obiekt, Buffer chyba że kodowanie zostało określone metodą readable.setEncoding() lub strumień działa w trybie obiektowym.

Argument opcjonalny size określa określoną liczbę bajtów do odczytu. Jeśli size bajty nie są dostępne do odczytu, zostaną zwrócone, nullchyba że strumień się zakończył, wtedy wszystkie dane pozostały w buforze wewnętrznym zostaną zwrócone.

Jeśli size argument nie zostanie określony, wszystkie dane zawarte w wewnętrznym buforze zostaną zwrócone.

Argument size musi być mniejszy lub równy 1 GiB.

Metoda powinna readable.read() być wywoływana tylko w strumieniach Readable działających w trybie pauzy. W trybie przepływu jest wywoływany automatycznie, readable.read() aż wewnętrzny bufor zostanie całkowicie opróżniony.

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

Każde wywołanie zwraca readable.read() fragment danych, czyli null. Fragmenty nie są połączone. Pętla jest konieczna, aby zużyć wszystkie dane obecnie znajdujące while się w buforze. Podczas odczytu dużego pliku .read() może się zwrócić null, po zużyciu całej dotychczas zbuforowanej zawartości, ale wciąż jest więcej danych, które nie są jeszcze buforowane. W takim przypadku nowe 'readable' zdarzenie zostanie wygenerowane, gdy w buforze pojawi się więcej danych. Na koniec 'end' wydarzenie zostanie wyemitowane, gdy nie będzie już więcej danych.

Dlatego aby odczytać całą zawartość pliku z , readablekonieczne jest zebranie fragmentów przez wiele 'readable' zdarzeń:

const chunks = [];

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

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

Strumień Readable w trybie obiektowym zawsze zwraca pojedynczy element z wywołania do readable.read(size), niezależnie od wartości argumentu size .

Jeśli readable.read() metoda zwraca fragment danych, zostanie również wygenerowane zdarzenie 'data' .

Wezwanie do odczytu po 'end' emisji zdarzenia wróci null. Nie pojawi się żaden błąd w czasie działania.

function read(size?: number): any

Parametry

size

number

Opcjonalny argument określający, ile danych należy odczytać.

Zwraca

any

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

Ta metoda wywołuje fn na każdym fragmencie strumienia w kolejności, przekazując mu wynik z obliczeń na poprzednim elemencie. Zwraca obietnicę końcowej wartości redukcji.

Jeśli nie podano wartości początkowej , jako wartość początkową używa się pierwszego fragmentu strumienia. Jeśli strumień jest pusty, obietnica jest odrzucana z TypeError właściwością z ERR_INVALID_ARGS kodem.

Funkcja reduktora iteruje strumień element po elemencie, co oznacza, że nie ma parametru współbieżności ani równoległości. Aby jednocześnie wykonać redukcję, możesz wyodrębnić funkcję asynchroniczną do readable.map metody.

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

Parametry

fn

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

funkcja redukująca do wywoływania każdego chunku w strumieniu. Niezależnie od tego, czy to asynchronicznie, czy nie.

Zwraca

Promise<T>

obietnica ostatecznej wartości redukcji.

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>

Parametry

fn

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

initial

T

options

Abortable

Zwraca

Promise<T>

removeAllListeners(string | symbol) 

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

Parametry

eventName

string | symbol

Zwraca

this

removeAllListeners<E>(E)

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

E

Zwraca

this

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

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

this

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

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wywołania removeListener() lub removeAllListeners() emisji i przed zakończeniem wykonania przez ostatniego słuchacza nie usuną ich z emit() trwających. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Ponieważ słuchacze są zarządzane za pomocą wewnętrznej tablicy, wywołanie tego zmienia indeksy pozycji każdego słuchacza zarejestrowanego po usunięciu tego nasłuchu. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

E

listener

(args: ReadableEventMap[E]) => void

Zwraca

this

resume()

Metoda ta readable.resume() powoduje, że wyraźnie wstrzymany Readable strumień wznawia emisję 'data' zdarzeń, przełączając strumień w tryb przepływu.

Metoda ta readable.resume() może być użyta do pełnego wykorzystania danych ze strumienia bez faktycznego przetwarzania tych danych:

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

Metoda nie readable.resume() ma efektu, jeśli istnieje 'readable' słuchacz zdarzeń.

function resume(): this

Zwraca

this

setEncoding(BufferEncoding)

Metoda ta readable.setEncoding() ustawia kodowanie znaków dla danych odczytanych Readable ze strumienia.

Domyślnie nie przypisuje się kodowania, a dane strumieniowe są zwracane jako Buffer obiekty. Ustawienie kodowania powoduje, że dane strumieniowe są zwracane jako ciągi znaków określonych kodów, a nie jako Buffer obiekty. Na przykład wywołanie readable.setEncoding('utf8') powoduje, że dane wyjściowe są interpretowane jako dane UTF-8 i przekazywane jako ciągi znaków. Wywołanie readable.setEncoding('hex') spowoduje zakodowanie danych w formacie szesnastkowego ciągu tekstowego.

Strumień Readable będzie prawidłowo obsługiwał znaki wielobajtowe dostarczane przez strumień, które w przeciwnym razie zostałyby niepoprawnie zdekodowane, gdyby zostały po prostu pobrane ze strumienia jako Buffer obiekty.

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

function setEncoding(encoding: BufferEncoding): this

Parametry

encoding

BufferEncoding

Kodowanie do użycia.

Zwraca

this

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

Ta metoda jest podobna do Array.prototype.some i wywołuje fn na każdym bloku strumienia, aż oczekiwana wartość zwrotu jest ( true lub dowolna wartość prawdziwa). Gdy wywołanie fn na wartości zwrotu chunk awaited jest prawdziwe, strumień zostaje zniszczony, a obietnica spełniona z .true Jeśli żadne z wywołań fn na blokach nie zwraca wartości prawdziwej, obietnica zostaje spełniona przez .false

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

Parametry

fn

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

funkcja wywołująca każdy fragment strumienia. Niezależnie od tego, czy to asynchronicznie, czy nie.

options

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

Zwraca

Promise<boolean>

Obietnica oceniająca na , true jeśli fn zwraca wartość prawdziwą przynajmniej dla jednego z chunków.

take(number, Abortable)

Ta metoda zwraca nowy strumień z pierwszymi blokami limitu .

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

Parametry

limit

number

Liczba fragmentów do pobrania z czytelnego.

options

Abortable

Zwraca

Readable

stream z limitem chunków.

toArray(Abortable)

Ta metoda pozwala łatwo uzyskać zawartość strumienia.

Ponieważ ta metoda odczytuje cały strumień do pamięci, niweluje korzyści płynące ze strumieni. Jest przeznaczony dla interoperacyjności i wygody, a nie jako główny sposób konsumowania strumieni.

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

Parametry

options

Abortable

Zwraca

Promise<any[]>

obietnica zawierająca tablicę z zawartością strumienia.

unpipe(WritableStream)

Metoda ta readable.unpipe() odłącza strumień wcześniej przymocowany Writable metodą rur.

Jeśli nie destination jest to określone, wszystkie rury są odłączane.

Jeśli jest destination określona, ale nie jest dla niej ustawiona żadna rura, to metoda nic nie robi.

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

function unpipe(destination?: WritableStream): this

Parametry

destination

WritableStream

Opcjonalny strumień specyficzny do odpięcia

Zwraca

this

unshift(any, BufferEncoding)

Przechodząc chunk jako null sygnalizuje koniec strumienia (EOF) i zachowuje się tak samo jak readable.push(null), po czym nie można już zapisać żadnych danych. Sygnał EOF jest umieszczany na końcu bufora, a wszystkie zbuforowane dane nadal są wypłukiwane.

Metoda ta readable.unshift() wsuwa fragment danych z powrotem do wewnętrznego bufora. Jest to przydatne w pewnych sytuacjach, gdy strumień jest konsumowany przez kod, który musi "odkonsumować" pewną ilość danych, które optymistycznym wyciągnął ze źródła, aby dane mogły zostać przekazane innej osobie.

Metoda nie stream.unshift(chunk) może być wywołana po 'end' wygenerowaniu zdarzenia, ponieważ w trakcie wykonywania zostanie wygenerowany błąd.

Programiści często korzystający powinni stream.unshift() rozważyć przejście na stream Transform zamiast tego. Zobacz sekcję API for stream implementers , aby uzyskać więcej informacji.

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

W przeciwieństwie do push, nie zakończy stream.unshift(chunk) procesu odczytu przez resetowanie wewnętrznego stanu odczytu strumienia. Może to powodować nieoczekiwane wyniki, jeśli readable.unshift() jest wywołany podczas odczytu (czyli z _read implementacji na niestandardowym strumieniu). readable.unshift() do wywołania zresetuje stan odczytu odpowiednio, jednak najlepiej unikać wywołań readable.unshift() podczas wykonywania odczytu.

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

Parametry

chunk

any

Fragment danych do przesunięcia do kolejki odczytu. Dla strumieni niedziałających w trybie obiektowym, chunk musi być {string}, {Buffer}, {TypedArray}, {DataView} lub null. Dla strumieni w trybie obiektowym może to chunk być dowolna wartość JavaScript.

encoding

BufferEncoding

Kodowanie fragmentów znaków znaków. Musi być poprawnym kodowaniem Buffer , takim jak 'utf8' lub 'ascii'.

wrap(ReadableStream)

Przed Node.js 0.10 strumienie nie implementowały całego node:stream API modułu w obecnej formie. (Zobacz więcej Compatibility informacji.)

Korzystając ze starszej biblioteki Node.js, która generuje 'data' zdarzenia i ma metodę pauzy działającą wyłącznie doradczo, metoda ta readable.wrap() może być użyta do stworzenia strumienia Readable wykorzystującego stary strumień jako źródło danych.

Rzadko będzie konieczna do użycia readable.wrap() , ale metoda ta została udostępniona jako wygoda do interakcji ze starszymi aplikacjami Node.js i bibliotekami.

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

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

function wrap(stream: ReadableStream): this

Parametry

stream

ReadableStream

"Stary styl" czytelny strumień

Zwraca

this

[asyncDispose]()

Dzwoni readable.destroy() z an AbortError i zwraca obietnicę, która spełnia się po zakończeniu streamu.

function [asyncDispose](): Promise<void>

Zwraca

Promise<void>

[asyncIterator]() 

function [asyncIterator](): AsyncIterator<any>

Zwraca

AsyncIterator<any>

AsyncIterator by w pełni pochłonąć strumień strumienia.

[toAsyncStreamable]()

Po włączeniu flagi --experimental-stream-iter strumienie implementują protokółReadable, Stream.toAsyncStreamable umożliwiając efektywne konsumpcje stream/iter przez API.

Zapewnia to partiowy asynchroniczny iterator, który odprowadza wstrzymek strumienia na Uint8Array[] partie, amortyzując narzut Promise na jeden fragment ścieżki standardowej Symbol.asyncIterator . W strumieniach bajtów fragmenty są bezpośrednio wydawane jako Buffer instancje (które są Uint8Array podklasami). Dla strumieni obiektowych lub kodowanych każdy fragment jest normalizowany do przed Uint8Array wsadowaniem.

Zwrócony iterator jest oznaczony jako zweryfikowane źródło, więc from() przekazuje go bez dodatkowej normalizacji.

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'

Bez flagi --experimental-stream-iter , wywołanie tej metody rzuca ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Zwraca

ByteReadableStream

Szczegóły metody dziedziczonej

eventNames()

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki.

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

Zwraca

(string | symbol)[]

Dziedziczone od Stream.eventNames

getMaxListeners()

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie ma wartość events.defaultMaxListeners.

function getMaxListeners(): number

Zwraca

number

Dziedziczone od Stream.getMaxListeners

pipe<T>(T, PipeOptions) 

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

Parametry

destination

T

options

PipeOptions

Zwraca

T

Dziedziczone od Stream.pipe

setMaxListeners(number)

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

function setMaxListeners(n: number): this

Parametry

n

number

Zwraca

this

Dziedziczone od Stream.setMaxListeners

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

Metoda ta Symbol.for('nodejs.rejection') jest wywoływana w przypadku, gdy podczas emisji zdarzenia następuje odrzucenie obietnicy i captureRejections jest włączona na emiterze. Można użyć events.captureRejectionSymbol go zamiast .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[])

Parametry

error

Error

event

string | symbol

args

any[]

Odziedziczone od Stream. [przechwycenieOdrzucenieSymbol]