Transport interface
- Extends
-
EventEmitter
Metódusok
Örökölt metódusok
add |
Alias a |
emit<K>(string | symbol, Any |
Szinkron módon meghívja a
|
event |
Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy
|
get |
A |
listener |
A |
listeners<K>(string | symbol) | A
|
off<K>(string | symbol, (args: any[]) => void) | Alias a |
on<K>(string | symbol, (args: any[]) => void) | Hozzáadja a
A Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A
|
once<K>(string | symbol, (args: any[]) => void) | Hozzáad egy egyszeri
A Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A
|
prepend |
Hozzáadja a
A |
prepend |
Hozzáad egy
A |
raw |
Visszaadja a
|
remove |
Eltávolítja az összes figyelőt vagy a megadott Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a A |
remove |
Eltávolítja a megadott
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 a
Mivel a figyelők kezelése belső tömb használatával történik, ennek meghívása megváltoztatja a figyelő eltávolítását követően Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan),
A |
set |
Alapértelmezés szerint A |
[capture |
Metódus adatai
connect(Callback<Connected>)
function connect(done?: Callback<Connected>)
Paraméterek
- done
-
Callback<Connected>
disconnect(Callback<Disconnected>)
function disconnect(done: Callback<Disconnected>)
Paraméterek
- done
-
Callback<Disconnected>
getFeedbackReceiver(Callback<ServiceReceiver>)
function getFeedbackReceiver(done: Callback<ServiceReceiver>)
Paraméterek
- done
-
Callback<ServiceReceiver>
getFileNotificationReceiver(Callback<ServiceReceiver>)
function getFileNotificationReceiver(done: Callback<ServiceReceiver>)
Paraméterek
- done
-
Callback<ServiceReceiver>
send(string, Message, Callback<MessageEnqueued>)
function send(deviceId: string, message: Message, done?: Callback<MessageEnqueued>)
Paraméterek
- deviceId
-
string
- message
-
Message
- done
-
Callback<MessageEnqueued>
Örökölt metódus részletei
addListener<K>(string | symbol, (args: any[]) => void)
Alias a emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
örökölt EventEmitter.addListener
emit<K>(string | symbol, AnyRest)
Szinkron módon meghívja a eventName
nevű 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<K>(eventName: string | symbol, args: AnyRest): boolean
Paraméterek
- eventName
-
string | symbol
- args
-
AnyRest
Válaszok
boolean
örökölt EventEmitter.emit
eventNames()
Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy Symbol
s.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
function eventNames(): (string | symbol)[]
Válaszok
(string | symbol)[]
örökölt EventEmitter.eventNames
getMaxListeners()
A EventEmitter
aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n)
vagy alapértelmezés szerint defaultMaxListenersértékre állít be.
function getMaxListeners(): number
Válaszok
number
Örökölt EventEmitter.getMaxListeners
listenerCount<K>(string | symbol, Function)
A eventName
nevű 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<K>(eventName: string | symbol, listener?: Function): number
Paraméterek
- eventName
-
string | symbol
A figyelt esemény neve
- listener
-
Function
Az eseménykezelő függvény
Válaszok
number
örökölt EventEmitter.listenerCount
listeners<K>(string | symbol)
A eventName
nevű 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<K>(eventName: string | symbol): Function[]
Paraméterek
- eventName
-
string | symbol
Válaszok
Function[]
örökölt EventEmitter.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias a emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
örökölt EventEmitter.off
on<K>(string | symbol, (args: any[]) => void)
Hozzáadja a listener
függvényt a eventName
nevű 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 EventEmitter
mutató 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<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
Az esemény neve.
- listener
-
(args: any[]) => void
A visszahívási függvény
Válaszok
örökölt EventEmitter.on
once<K>(string | symbol, (args: any[]) => void)
Hozzáad egy egyszerilistener
függvényt a eventName
nevű 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 EventEmitter
mutató 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<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
Az esemény neve.
- listener
-
(args: any[]) => void
A visszahívási függvény
Válaszok
örökölt EventEmitter.once
prependListener<K>(string | symbol, (args: any[]) => void)
Hozzáadja 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 EventEmitter
mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
Az esemény neve.
- listener
-
(args: any[]) => void
A visszahívási függvény
Válaszok
örökölt EventEmitter.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Hozzáad egy 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 EventEmitter
mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
Az esemény neve.
- listener
-
(args: any[]) => void
A visszahívási függvény
Válaszok
örökölt EventEmitter.prependOnceListener
rawListeners<K>(string | symbol)
Visszaadja a eventName
nevű 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<K>(eventName: string | symbol): Function[]
Paraméterek
- eventName
-
string | symbol
Válaszok
Function[]
örökölt EventEmitter.rawListeners
removeAllListeners(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 EventEmitter
mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
function removeAllListeners(eventName?: string | symbol): Transport
Paraméterek
- eventName
-
string | symbol
Válaszok
Örökölt EventEmitter.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Eltávolítja a megadott listener
a eventName
nevű 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 eventName
egyetlen 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 a removeListener()
vagy removeAllListeners()
hívások kibocsátás és után, mielőtt az utolsó figyelő befejezi a végrehajtást, nem távolítja el őket a folyamatban lévőemit()
. 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 figyelők kezelése belső tömb használatával történik, ennek meghívása megváltoztatja a figyelő eltávolítását követően 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 EventEmitter
mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Transport
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
örökölt EventEmitter.removeListener
setMaxListeners(number)
Alapértelmezés szerint EventEmitter
s 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 EventEmitter
mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
function setMaxListeners(n: number): Transport
Paraméterek
- n
-
number
Válaszok
Örökölt EventEmitter.setMaxListeners
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Paraméterek
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
örökölt EventEmitter.__@captureRejectionSymbol@119