NodeJSReadableStream interface

Csomag:
@azure/storage-blob

Egy Node.js olvasható stream, amely szintén rendelkezik metódussal destroy .

Extends

ReadableStream

Örökölt tulajdonságok

readable

Metódusok

destroy(Error)

Pusztítsd el a patakot. Igény szerint "hiba" eseményt bocsát ki, és "bezárás" eseményt bocsát ki (kivéve, ha az emitClose értéke hamis). A hívás után a rendszer felszabadítja a belső erőforrásokat.

Örökölt metódusok

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

Alias a következőhöz emitter.on(eventName, listener): .
emit<E>(string | symbol, any[])

Szinkron módon meghívja a eventNamenevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

true ad vissza, ha az esemény figyelői voltak, false ellenkező esetben.

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
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.
isPaused()
listenerCount<E>(string | symbol, (args: any[]) => void)

A eventNamenevű eseményt figyelő figyelők számát adja vissza. Ha listener van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.
listeners<E>(string | symbol)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
off<E>(string | symbol, (args: any[]) => void)

Alias a következőhöz emitter.removeListener(): .
on<E>(string | symbol, (args: any[]) => void)

Hozzáadja a listener függvényt a eventNamenevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

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

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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<E>(string | symbol, (args: any[]) => void)

Hozzáad egy egyszerilistener függvényt a eventNamenevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

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

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependOnceListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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()
pipe<T>(T, { end?: boolean })
prependListener<E>(string | symbol, (args: any[]) => void)

Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
prependOnceListener<E>(string | symbol, (args: any[]) => void)

Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
rawListeners<E>(string | symbol)

Visszaadja a eventNamenevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az .once()által létrehozottakat).

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)
removeAllListeners<E>(string | symbol)

Eltávolítja az összes figyelőt vagy a megadott eventName.

Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a EventEmitter-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek).

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
removeListener<E>(string | symbol, (args: any[]) => void)

Eltávolítja a megadott listener a eventNamenevű esemény figyelőtömbéből.

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

removeListener() legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott eventNameegyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához removeListener() többször kell meghívni.

Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy removeListener()removeAllListeners() a hívások a kibocsátás után, mielőtt az utolsó hallgató befejezi a végrehajtást, nem távolítják el a emit() folyamatból. A későbbi események a várt módon viselkednek.

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

Mivel a hallgatókat belső tömbben kezelik, ennek meghívása megváltoztatja bármely hallgató pozícióindexét , amelyet a hallgató eltávolítása után regisztrálnak. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az emitter.listeners() metódus által visszaadott másolatait újra létre kell hozni.

Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), removeListener() eltávolítja a legutóbb hozzáadott példányt. A példában a once('ping') figyelő el lesz távolítva:

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
resume()
setEncoding(BufferEncoding)
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.
unpipe(WritableStream)
unshift(string | Uint8Array, BufferEncoding)
wrap(ReadableStream)
[asyncIterator]()
[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.
  }
}

Örökölt tulajdonság részletei

readable 

readable: boolean

Tulajdonság értéke

boolean

Öröklött forrás NodeJS.ReadableStream.readable

Metódus adatai

destroy(Error)

Pusztítsd el a patakot. Igény szerint "hiba" eseményt bocsát ki, és "bezárás" eseményt bocsát ki (kivéve, ha az emitClose értéke hamis). A hívás után a rendszer felszabadítja a belső erőforrásokat.

function destroy(error?: Error): this

Paraméterek

error

Error

Válaszok

this

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

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

Alias a következőhöz emitter.on(eventName, listener): .

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.addListener

emit<E>(string | symbol, any[])

Szinkron módon meghívja a eventNamenevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

true ad vissza, ha az esemény figyelői voltak, false ellenkező esetben.

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: string | symbol, args: any[]): boolean

Paraméterek

eventName

string | symbol

args

any[]

Válaszok

boolean

Öröklött forrás NodeJS.ReadableStream.emit

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öklött forrás NodeJS.ReadableStream.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öklött forrás NodeJS.ReadableStream.getMaxListeners

isPaused() 

function isPaused(): boolean

Válaszok

boolean

Öröklött forrás NodeJS.ReadableStream.isPaused

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

A eventNamenevű eseményt figyelő figyelők számát adja vissza. Ha listener van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.

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

Paraméterek

eventName

string | symbol

A figyelt esemény neve

listener

(args: any[]) => void

Az eseménykezelő függvény

Válaszok

number

Öröklött forrás NodeJS.ReadableStream.listenerCount

listeners<E>(string | symbol)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

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

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

Paraméterek

eventName

string | symbol

Válaszok

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

Öröklött forrás NodeJS.ReadableStream.listeners

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

Alias a következőhöz emitter.removeListener(): .

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.off

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

Hozzáadja a listener függvényt a eventNamenevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

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

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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: string | symbol, listener: (args: any[]) => void): this

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.on

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

Hozzáad egy egyszerilistener függvényt a eventNamenevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

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

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependOnceListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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: string | symbol, listener: (args: any[]) => void): this

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.once

pause() 

function pause(): this

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.pause

pipe<T>(T, { end?: boolean }) 

function pipe<T>(destination: T, options?: { end?: boolean }): T

Paraméterek

destination

T

options

{ end?: boolean }

Válaszok

T

Öröklött forrás NodeJS.ReadableStream.pipe

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

Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

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

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.prependListener

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

Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

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

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.prependOnceListener

rawListeners<E>(string | symbol)

Visszaadja a eventNamenevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az .once()által létrehozottakat).

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: string | symbol): (args: any[]) => void[]

Paraméterek

eventName

string | symbol

Válaszok

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

Öröklött forrás NodeJS.ReadableStream.rawListeners

read(number) 

function read(size?: number): string | Buffer

Paraméterek

size

number

Válaszok

string | Buffer

Öröklött forrás NodeJS.ReadableStream.read

removeAllListeners<E>(string | symbol)

Eltávolítja az összes figyelőt vagy a megadott eventName.

Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a EventEmitter-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek).

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

function removeAllListeners<E>(eventName?: string | symbol): this

Paraméterek

eventName

string | symbol

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.removeAllListeners

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

Eltávolítja a megadott listener a eventNamenevű esemény figyelőtömbéből.

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

removeListener() legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott eventNameegyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához removeListener() többször kell meghívni.

Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy removeListener()removeAllListeners() a hívások a kibocsátás után, mielőtt az utolsó hallgató befejezi a végrehajtást, nem távolítják el a emit() folyamatból. A későbbi események a várt módon viselkednek.

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

Mivel a hallgatókat belső tömbben kezelik, ennek meghívása megváltoztatja bármely hallgató pozícióindexét , amelyet a hallgató eltávolítása után regisztrálnak. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az emitter.listeners() metódus által visszaadott másolatait újra létre kell hozni.

Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), removeListener() eltávolítja a legutóbb hozzáadott példányt. A példában a once('ping') figyelő el lesz távolítva:

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

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.removeListener

resume() 

function resume(): this

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.resume

setEncoding(BufferEncoding) 

function setEncoding(encoding: BufferEncoding): this

Paraméterek

encoding

BufferEncoding

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.setEncoding

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

Paraméterek

n

number

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.setMaxListeners

unpipe(WritableStream) 

function unpipe(destination?: WritableStream): this

Paraméterek

destination

WritableStream

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.unpipe

unshift(string | Uint8Array, BufferEncoding) 

function unshift(chunk: string | Uint8Array, encoding?: BufferEncoding)

Paraméterek

chunk

string | Uint8Array

encoding

BufferEncoding

Öröklött forrás NodeJS.ReadableStream.unshift

wrap(ReadableStream) 

function wrap(oldStream: ReadableStream): this

Paraméterek

oldStream

ReadableStream

Válaszok

this

Öröklött forrás NodeJS.ReadableStream.wrap

[asyncIterator]() 

function [asyncIterator](): AsyncIterableIterator<string | Buffer>

Válaszok

AsyncIterableIterator<string | Buffer>

Örökölve NodeJS.ReadableStream. [asyncIterator]

[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ölve NodeJS.ReadableStream-ről. [captureRejectionSymbol]