Sdílet prostřednictvím

Client class

  • Reference
Balíček:
azure-iot-device

Klient zařízení služby IoT Hub používaný k připojení zařízení k centru Azure IoT.

Uživatelé sady SDK by měli volat jednu z metod továrny, zconnectionString nebo zesharedAccessSignature vytvořit klienta zařízení IoT Hubu.

Extends

InternalClient

Konstruktory

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Zděděné vlastnosti

captureRejections

Hodnota: logická

U všech nových objektů captureRejections změňte výchozí možnost EventEmitter.
captureRejectionSymbol

Hodnota: Symbol.for('nodejs.rejection')

Podívejte se, jak napsat vlastní rejection handler.
defaultMaxListeners

Ve výchozím nastavení je možné zaregistrovat maximálně 10 naslouchací procesy pro libovolnou událost. Tento limit lze změnit pro jednotlivé instance EventEmitter pomocí metody emitter.setMaxListeners(n). Chcete-li změnit výchozí hodnotu pro všechny instanceEventEmitter, lze použít vlastnost events.defaultMaxListeners. Pokud tato hodnota není kladné číslo, vyvolá se RangeError.

Při nastavování events.defaultMaxListeners buďte opatrní, protože tato změna ovlivňuje všechny instanceEventEmitter, včetně těch vytvořených před provedením změny. Volání emitter.setMaxListeners(n) však stále má přednost před events.defaultMaxListeners.

To není pevný limit. Instance EventEmitter umožní přidání dalších naslouchacích procesů, ale vypíše upozornění trasování stderru, které indikuje, že byla zjištěna "možná nevracení paměti EventEmitter". Pro každou jednu EventEmitterje možné použít metody emitter.getMaxListeners() a emitter.setMaxListeners() k dočasnému zabránění tomuto upozornění:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Příznak příkazového řádku --trace-warnings lze použít k zobrazení trasování zásobníku pro taková upozornění.

Vygenerované upozornění je možné zkontrolovat pomocí process.on('warning') a bude obsahovat další emitter, typea count vlastnosti, odkazující na instanci emiteru události, název události a počet připojených naslouchacích procesů. Jeho name vlastnost je nastavena na 'MaxListenersExceededWarning'.
errorMonitor

Tento symbol se použije k instalaci naslouchacího procesu pouze pro monitorování 'error' událostí. Naslouchací procesy nainstalované pomocí tohoto symbolu se volají před zavolání běžných 'error' naslouchacích procesů.

Instalace naslouchacího procesu pomocí tohoto symbolu nezmění chování po vygenerování 'error' události. Proto se proces stále chybově ukončí, pokud není nainstalován žádný běžný 'error' naslouchací proces.

Metody

close()
close(Callback<Disconnected>)

Ukončí přenosové připojení a zničí prostředky klienta.

Poznámka: Po volání této metody nelze objekt Client znovu použít.
fromAuthenticationProvider(AuthenticationProvider, any)

Vytvoří klienta zařízení IoT Hubu z dané metody ověřování a použije daný typ přenosu.
fromConnectionString(string, any)

Vytvoří klienta zařízení IoT Hubu z daného připojovacího řetězce pomocí daného typu přenosu.
fromSharedAccessSignature(string, any)

Vytvoří klienta zařízení IoT Hubu z daného sdíleného přístupového podpisu pomocí daného typu přenosu.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)

getBlobSharedAccessSignature získá token SAS propojeného účtu úložiště ze služby IoT Hub.
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

Metoda notifyBlobUploadStatus odešle IoT Hub výsledek nahrání objektu blob.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Zaregistruje zpětné volání metody s názvem methodName.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)

Metoda uploadToBlob nahraje datový proud do objektu blob.

Zděděné metody

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)

Naslouchá jednou události abort na zadaném signal.

Naslouchání abort události na přerušených signálech je nebezpečné a může vést k úniku prostředků, protože jiná třetí strana s signálem může volat e.stopImmediatePropagation(). Bohužel Node.js to nemůže změnit, protože by porušil webovou normu. Kromě toho původní rozhraní API usnadňuje odebrání naslouchacích procesů.

Toto rozhraní API umožňuje bezpečně používat AbortSignals v rozhraních Node.js API tím, že tyto dva problémy vyřešíte nasloucháním události, aby stopImmediatePropagation nezabránil spuštění naslouchacího procesu.

Vrátí jedno použití, aby se mohlo odhlásit od odběru snadněji.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}
addListener<K>(string | symbol, (args: any[]) => void)

Alias pro emitter.on(eventName, listener).
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

Synchronně volá všechny naslouchací procesy zaregistrované pro událost s názvem eventName, v pořadí, v jakém byly zaregistrovány, předávání zadaných argumentů každému.

Vrátí true, pokud událost měla naslouchací procesy, false jinak.

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

Vrátí pole se seznamem událostí, pro které má emiter zaregistrované naslouchací procesy. Hodnoty v poli jsou řetězce nebo Symbols.

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) ]
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName.

U EventEmitterse chová úplně stejně jako volání .listeners na emitteru.

Pro EventTargetje to jediný způsob, jak získat naslouchací procesy událostí pro cíl události. To je užitečné pro účely ladění a diagnostiky.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
getMaxListeners()

Vrátí aktuální hodnotu maximálního naslouchacího procesu pro EventEmitter, která je buď nastavena emitter.setMaxListeners(n), nebo výchozí hodnota defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Vrátí aktuálně nastavené maximální množství naslouchacích procesů.

U EventEmitterse chová úplně stejně jako volání .getMaxListeners na emitteru.

Pro EventTargetje to jediný způsob, jak získat maximální počet naslouchacích procesů událostí pro cíl události. Pokud počet obslužných rutin událostí v jednom eventTargetu překročí maximální sadu, eventTarget vytiskne upozornění.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Metoda třídy, která vrátí počet naslouchacích procesů pro danou eventName zaregistrovanou na daném emitter.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
listenerCount<K>(string | symbol, Function)

Vrátí počet naslouchacích procesů naslouchajících události s názvem eventName. Pokud listener, vrátí se v seznamu naslouchacích procesů události, kolikrát se naslouchací proces najde.
listeners<K>(string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName.

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

Alias pro emitter.removeListener().
on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Vrátí AsyncIterator, který iteruje eventName událostí. Vyvolá se, pokud EventEmitter vygeneruje 'error'. Při ukončení smyčky se odeberou všechny naslouchací procesy. value vrácená každou iterací je pole složené z argumentů vygenerovaných událostí.

K zrušení čekání na události můžete použít AbortSignal:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Pomocí možnosti close zadejte pole názvů událostí, které ukončí iteraci:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string | symbol, (args: any[]) => void)

Přidá funkci listener na konec pole naslouchacích procesů pro událost s názvem eventName. Nejsou provedeny žádné kontroly, abyste zjistili, jestli už listener byla přidána. Více volání, která předávají stejnou kombinaci eventName a listener, způsobí přidání listener a volání několikrát.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

Ve výchozím nastavení se naslouchací procesy událostí vyvolávají v pořadí, v jakém se přidávají. Metodu emitter.prependListener() lze použít jako alternativu k přidání naslouchacího procesu událostí na začátek pole naslouchacích procesů.

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(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Vytvoří Promise, která je splněna, když EventEmitter vygeneruje danou událost nebo je odmítnuta, pokud EventEmitter generuje 'error' během čekání. Promise se přeloží s polem všech argumentů vygenerovaných pro danou událost.

Tato metoda je záměrně obecná a pracuje s webovou platformou eventTarget rozhraní, které nemá žádné zvláštní'error' sémantiku událostí a neposlouchá 'error' události.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

Speciální zpracování události 'error' se používá pouze v případě, že events.once() slouží k čekání na jinou událost. Pokud se events.once() používá k čekání na samotnou událost "error', považuje se za jakýkoli jiný druh události bez zvláštního zpracování:

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

K zrušení čekání na událost můžete použít AbortSignal:

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
once(EventTarget, string, StaticEventEmitterOptions)
once<K>(string | symbol, (args: any[]) => void)

Přidá jednorázovou funkcilistener pro událost s názvem eventName. Při příštím spuštění eventName se tento naslouchací proces odebere a potom se vyvolá.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

Ve výchozím nastavení se naslouchací procesy událostí vyvolávají v pořadí, v jakém se přidávají. Metodu emitter.prependOnceListener() lze použít jako alternativu k přidání naslouchacího procesu událostí na začátek pole naslouchacích procesů.

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
open()
open(Callback<Connected>)
prependListener<K>(string | symbol, (args: any[]) => void)

Přidá funkci listener do začínající pole naslouchacích procesů pro událost s názvem eventName. Nejsou provedeny žádné kontroly, abyste zjistili, jestli už listener byla přidána. Více volání, která předávají stejnou kombinaci eventName a listener, způsobí přidání listener a volání několikrát.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Přidá jednorázovélistener funkce pro událost s názvem eventName do začínající pole naslouchacích procesů. Při příštím spuštění eventName se tento naslouchací proces odebere a potom se vyvolá.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.
rawListeners<K>(string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName, včetně všech obálky (například těch vytvořených .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');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string | symbol)

Odebere všechny naslouchací procesy nebo naslouchací procesy zadané eventName.

Je vhodné odebrat naslouchací procesy přidané jinde v kódu, zejména pokud byla instance EventEmitter vytvořená nějakou jinou komponentou nebo modulem (např. sokety nebo streamy souborů).

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.
removeListener<K>(string | symbol, (args: any[]) => void)

Odebere zadanou listener z pole naslouchacího procesu pro událost s názvem eventName.

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

removeListener() odebere z pole naslouchacího procesu nanejvýš jednu instanci naslouchacího procesu. Pokud byl některý jeden naslouchací proces přidán vícekrát do pole naslouchacího procesu pro zadané eventName, pak removeListener() musí být volána vícekrát, aby bylo možné odebrat každou instanci.

Jakmile se událost vygeneruje, všechny naslouchací procesy, které jsou k ní připojeny v době generování, se volají v pořadí. To znamená, že všechny removeListener() nebo removeAllListeners() volání po vygenerování a před dokončením posledního naslouchacího procesu je neodeberou zemit() probíhajícího. Následné události se chovají podle očekávání.

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

Vzhledem k tomu, že naslouchací procesy se spravují pomocí interního pole, při volání se změní indexy pozice libovolného naslouchacího procesu registrovaného po odebrání naslouchacího procesu. To nebude mít vliv na pořadí, ve kterém se volají naslouchací procesy, ale znamená to, že všechny kopie pole naslouchacího procesu vrácené metodou emitter.listeners() bude potřeba znovu vytvořit.

Když je jedna funkce přidána jako obslužná rutina několikrát pro jednu událost (jako v příkladu níže), removeListener() odebere naposledy přidanou instanci. V příkladu se odebere naslouchací proces once('ping'):

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Ve výchozím nastavení EventEmitters zobrazí upozornění, pokud se pro konkrétní událost přidá více než 10 naslouchací procesy. Toto je užitečné výchozí nastavení, které pomáhá najít nevrácenou paměť. Metoda emitter.setMaxListeners() umožňuje upravit limit pro tuto konkrétní instanci EventEmitter. Hodnotu lze nastavit na Infinity (nebo 0), aby bylo možné označit neomezený počet naslouchacích procesů.

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);
setRetryPolicy(RetryPolicy)

Nastaví zásadu opakování používanou klientem pro všechny operace. Výchozí hodnota je ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Podrobnosti konstruktoru

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface) 

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

Parametry

transport
DeviceTransport

Objekt, který implementuje rozhraní očekávaného přenosového objektu, například Http.

connStr

string

Připojovací řetězec (volitelné: pokud není k dispozici, musí být volán updateSharedAccessSignature, aby se token SharedAccessSignature nastavil přímo).

blobUploadClient

BlobUploadClient

Objekt, který dokáže nahrát datový proud do objektu blob.

fileUploadApi

FileUploadInterface

Objekt, který se používá ke komunikaci se službou IoT Hub pro akce související se službou Blob Storage.

Podrobnosti zděděných vlastností

captureRejections

Hodnota: logická

U všech nových objektů captureRejections změňte výchozí možnost EventEmitter.

static captureRejections: boolean

Hodnota vlastnosti

boolean

zděděno z InternalClient.captureRejections

captureRejectionSymbol

Hodnota: Symbol.for('nodejs.rejection')

Podívejte se, jak napsat vlastní rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Hodnota vlastnosti

typeof captureRejectionSymbol

zděděno z InternalClient.captureRejectionSymbol

defaultMaxListeners

Ve výchozím nastavení je možné zaregistrovat maximálně 10 naslouchací procesy pro libovolnou událost. Tento limit lze změnit pro jednotlivé instance EventEmitter pomocí metody emitter.setMaxListeners(n). Chcete-li změnit výchozí hodnotu pro všechny instanceEventEmitter, lze použít vlastnost events.defaultMaxListeners. Pokud tato hodnota není kladné číslo, vyvolá se RangeError.

Při nastavování events.defaultMaxListeners buďte opatrní, protože tato změna ovlivňuje všechny instanceEventEmitter, včetně těch vytvořených před provedením změny. Volání emitter.setMaxListeners(n) však stále má přednost před events.defaultMaxListeners.

To není pevný limit. Instance EventEmitter umožní přidání dalších naslouchacích procesů, ale vypíše upozornění trasování stderru, které indikuje, že byla zjištěna "možná nevracení paměti EventEmitter". Pro každou jednu EventEmitterje možné použít metody emitter.getMaxListeners() a emitter.setMaxListeners() k dočasnému zabránění tomuto upozornění:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Příznak příkazového řádku --trace-warnings lze použít k zobrazení trasování zásobníku pro taková upozornění.

Vygenerované upozornění je možné zkontrolovat pomocí process.on('warning') a bude obsahovat další emitter, typea count vlastnosti, odkazující na instanci emiteru události, název události a počet připojených naslouchacích procesů. Jeho name vlastnost je nastavena na 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Hodnota vlastnosti

number

zděděno z InternalClient.defaultMaxListeners

errorMonitor

Tento symbol se použije k instalaci naslouchacího procesu pouze pro monitorování 'error' událostí. Naslouchací procesy nainstalované pomocí tohoto symbolu se volají před zavolání běžných 'error' naslouchacích procesů.

Instalace naslouchacího procesu pomocí tohoto symbolu nezmění chování po vygenerování 'error' události. Proto se proces stále chybově ukončí, pokud není nainstalován žádný běžný 'error' naslouchací proces.

static errorMonitor: typeof errorMonitor

Hodnota vlastnosti

typeof errorMonitor

zděděno z InternalClient.errorMonitor

Podrobnosti metody

close() 

function close(): Promise<Disconnected>

Návraty

Promise<Disconnected>

close(Callback<Disconnected>)

Ukončí přenosové připojení a zničí prostředky klienta.

Poznámka: Po volání této metody nelze objekt Client znovu použít.

function close(closeCallback?: Callback<Disconnected>)

Parametry

closeCallback

Callback<Disconnected>

Volitelná funkce, která se má volat po odpojení přenosu a zavření klienta.

fromAuthenticationProvider(AuthenticationProvider, any)

Vytvoří klienta zařízení IoT Hubu z dané metody ověřování a použije daný typ přenosu.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client

Parametry

authenticationProvider

AuthenticationProvider

Objekt použitý k získání parametrů ověřování pro centrum IoT.

transportCtor

any

Přenosový protokol používaný k připojení k IoT Hubu

Návraty

Client

fromConnectionString(string, any)

Vytvoří klienta zařízení IoT Hubu z daného připojovacího řetězce pomocí daného typu přenosu.

static function fromConnectionString(connStr: string, transportCtor: any): Client

Parametry

connStr

string

Připojovací řetězec, který zapouzdřuje oprávnění "device connect" v centru IoT.

transportCtor

any

Dopravní konstruktor.

Návraty

Client

fromSharedAccessSignature(string, any)

Vytvoří klienta zařízení IoT Hubu z daného sdíleného přístupového podpisu pomocí daného typu přenosu.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client

Parametry

sharedAccessSignature

string

Sdílený přístupový podpis, který zapouzdřuje oprávnění "device connect" v centru IoT.

transportCtor

any

Návraty

Client

getBlobSharedAccessSignature(string) 

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

Parametry

blobName

string

Návraty

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

getBlobSharedAccessSignature získá token SAS propojeného účtu úložiště ze služby IoT Hub.

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

Parametry

blobName

string

Název, který se použije pro objekt blob, který se vytvoří s obsahem datového proudu.

callback

Callback<UploadParams>

Volitelné zpětné volání pro volání po dokončení nahrávání.

notifyBlobUploadStatus(string, boolean, number, string) 

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

Parametry

correlationId

string

isSuccess

boolean

statusCode

number

statusDescription

string

Návraty

Promise<void>

notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

Metoda notifyBlobUploadStatus odešle IoT Hub výsledek nahrání objektu blob.

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

Parametry

correlationId

string

ID pro korelaci stavu nahrání s konkrétním objektem blob. Vygenerováno během volání getBlobSharedAccessSignature.

isSuccess

boolean

Stav úspěchu nebo selhání z výsledku operace objektu blob úložiště.

statusCode

number

Stavový kód HTTP přidružený k výsledku objektu blob úložiště.

statusDescription

string

Popis stavového kódu HTTP.

callback

ErrorCallback

Volitelné zpětné volání pro volání po dokončení nahrávání.

onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Zaregistruje zpětné volání metody s názvem methodName.

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parametry

methodName

string

Název metody, která bude zpracována zpětným voláním

callback

(request: DeviceMethodRequest, response: DeviceMethodResponse) => void

Funkce, která se volá při každém přijetí požadavku metody na metodu s názvem methodName.

setOptions(DeviceClientOptions) 

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Parametry

options
DeviceClientOptions

Návraty

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>) 

function setOptions(options: DeviceClientOptions, done: Callback<TransportConfigured>)

Parametry

options
DeviceClientOptions
done

Callback<TransportConfigured>

uploadToBlob(string, Stream, number) 

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

Parametry

blobName

string

stream

Stream

streamLength

number

Návraty

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

Metoda uploadToBlob nahraje datový proud do objektu blob.

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

Parametry

blobName

string

Název, který se použije pro objekt blob, který se vytvoří s obsahem datového proudu.

stream

Stream

Data, která se mají nahrát do objektu blob.

streamLength

number

Velikost dat, která se mají nahrát do objektu blob.

callback

ErrorCallback

Podrobnosti zděděných metod

abandon(Message) 

function abandon(message: Message): Promise<MessageAbandoned>

Parametry

message
Message

Návraty

Promise<MessageAbandoned>

zděděno z InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Parametry

message
Message
abandonCallback

Callback<MessageAbandoned>

zděděno z InternalClient.abandon

addAbortListener(AbortSignal, (event: Event) => void)

Naslouchá jednou události abort na zadaném signal.

Naslouchání abort události na přerušených signálech je nebezpečné a může vést k úniku prostředků, protože jiná třetí strana s signálem může volat e.stopImmediatePropagation(). Bohužel Node.js to nemůže změnit, protože by porušil webovou normu. Kromě toho původní rozhraní API usnadňuje odebrání naslouchacích procesů.

Toto rozhraní API umožňuje bezpečně používat AbortSignals v rozhraních Node.js API tím, že tyto dva problémy vyřešíte nasloucháním události, aby stopImmediatePropagation nezabránil spuštění naslouchacího procesu.

Vrátí jedno použití, aby se mohlo odhlásit od odběru snadněji.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Parametry

signal

AbortSignal

resource

(event: Event) => void

Návraty

Disposable

Uvolnitelné, které odebere naslouchací proces abort.

zděděno z InternalClient.addAbortListener

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

Alias pro emitter.on(eventName, listener).

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Návraty

Client

zděděno z InternalClient.addListener

complete(Message) 

function complete(message: Message): Promise<MessageCompleted>

Parametry

message
Message

Návraty

Promise<MessageCompleted>

zděděno z InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parametry

message
Message
completeCallback

Callback<MessageCompleted>

zděděno z InternalClient.complete

emit<K>(string | symbol, AnyRest)

Synchronně volá všechny naslouchací procesy zaregistrované pro událost s názvem eventName, v pořadí, v jakém byly zaregistrovány, předávání zadaných argumentů každému.

Vrátí true, pokud událost měla naslouchací procesy, false jinak.

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

Parametry

eventName

string | symbol

args

AnyRest

Návraty

boolean

zděděno z InternalClient.emit

eventNames()

Vrátí pole se seznamem událostí, pro které má emiter zaregistrované naslouchací procesy. Hodnoty v poli jsou řetězce nebo Symbols.

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

Návraty

(string | symbol)[]

zděděné z InternalClient.eventNames

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName.

U EventEmitterse chová úplně stejně jako volání .listeners na emitteru.

Pro EventTargetje to jediný způsob, jak získat naslouchací procesy událostí pro cíl události. To je užitečné pro účely ladění a diagnostiky.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Parametry

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Návraty

Function[]

zděděné z InternalClient.getEventListeners

getMaxListeners()

Vrátí aktuální hodnotu maximálního naslouchacího procesu pro EventEmitter, která je buď nastavena emitter.setMaxListeners(n), nebo výchozí hodnota defaultMaxListeners.

function getMaxListeners(): number

Návraty

number

zděděné z InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Vrátí aktuálně nastavené maximální množství naslouchacích procesů.

U EventEmitterse chová úplně stejně jako volání .getMaxListeners na emitteru.

Pro EventTargetje to jediný způsob, jak získat maximální počet naslouchacích procesů událostí pro cíl události. Pokud počet obslužných rutin událostí v jednom eventTargetu překročí maximální sadu, eventTarget vytiskne upozornění.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Parametry

emitter

EventEmitter<DefaultEventMap> | EventTarget

Návraty

number

zděděné z InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Návraty

Promise<Twin>

zděděno z InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parametry

done

Callback<Twin>

zděděno z InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Upozornění

Toto rozhraní API je teď zastaralé.

Since v3.2.0 - Use listenerCount instead.

Metoda třídy, která vrátí počet naslouchacích procesů pro danou eventName zaregistrovanou na daném emitter.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Parametry

emitter

EventEmitter<DefaultEventMap>

Emitter k dotazování

eventName

string | symbol

Název události

Návraty

number

zděděno z InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Vrátí počet naslouchacích procesů naslouchajících události s názvem eventName. Pokud listener, vrátí se v seznamu naslouchacích procesů události, kolikrát se naslouchací proces najde.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parametry

eventName

string | symbol

Název události, pro kterou se naslouchá

listener

Function

Funkce obslužné rutiny události

Návraty

number

zděděno z InternalClient.listenerCount

listeners<K>(string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName.

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

function listeners<K>(eventName: string | symbol): Function[]

Parametry

eventName

string | symbol

Návraty

Function[]

zděděné z InternalClient.listeners

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

Alias pro emitter.removeListener().

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Návraty

Client

zděděno z InternalClient.off

on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Vrátí AsyncIterator, který iteruje eventName událostí. Vyvolá se, pokud EventEmitter vygeneruje 'error'. Při ukončení smyčky se odeberou všechny naslouchací procesy. value vrácená každou iterací je pole složené z argumentů vygenerovaných událostí.

K zrušení čekání na události můžete použít AbortSignal:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Pomocí možnosti close zadejte pole názvů událostí, které ukončí iteraci:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametry

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Návraty

AsyncIterator<any[], any, any>

AsyncIterator, který iteruje eventName události generované emitter

zděděno z InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametry

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Návraty

AsyncIterator<any[], any, any>

zděděno z InternalClient.on

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

Přidá funkci listener na konec pole naslouchacích procesů pro událost s názvem eventName. Nejsou provedeny žádné kontroly, abyste zjistili, jestli už listener byla přidána. Více volání, která předávají stejnou kombinaci eventName a listener, způsobí přidání listener a volání několikrát.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

Ve výchozím nastavení se naslouchací procesy událostí vyvolávají v pořadí, v jakém se přidávají. Metodu emitter.prependListener() lze použít jako alternativu k přidání naslouchacího procesu událostí na začátek pole naslouchacích procesů.

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

Parametry

eventName

string | symbol

Název události.

listener

(args: any[]) => void

Funkce zpětného volání

Návraty

Client

zděděno z InternalClient.on

once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Vytvoří Promise, která je splněna, když EventEmitter vygeneruje danou událost nebo je odmítnuta, pokud EventEmitter generuje 'error' během čekání. Promise se přeloží s polem všech argumentů vygenerovaných pro danou událost.

Tato metoda je záměrně obecná a pracuje s webovou platformou eventTarget rozhraní, které nemá žádné zvláštní'error' sémantiku událostí a neposlouchá 'error' události.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

Speciální zpracování události 'error' se používá pouze v případě, že events.once() slouží k čekání na jinou událost. Pokud se events.once() používá k čekání na samotnou událost "error', považuje se za jakýkoli jiný druh události bez zvláštního zpracování:

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

K zrušení čekání na událost můžete použít AbortSignal:

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parametry

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Návraty

Promise<any[]>

zděděno z InternalClient.once

once(EventTarget, string, StaticEventEmitterOptions) 

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parametry

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Návraty

Promise<any[]>

zděděno z InternalClient.once

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

Přidá jednorázovou funkcilistener pro událost s názvem eventName. Při příštím spuštění eventName se tento naslouchací proces odebere a potom se vyvolá.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

Ve výchozím nastavení se naslouchací procesy událostí vyvolávají v pořadí, v jakém se přidávají. Metodu emitter.prependOnceListener() lze použít jako alternativu k přidání naslouchacího procesu událostí na začátek pole naslouchacích procesů.

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

Parametry

eventName

string | symbol

Název události.

listener

(args: any[]) => void

Funkce zpětného volání

Návraty

Client

zděděno z InternalClient.once

open() 

function open(): Promise<Connected>

Návraty

Promise<Connected>

zděděno z InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parametry

openCallback

Callback<Connected>

zděděno z InternalClient.open

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

Přidá funkci listener do začínající pole naslouchacích procesů pro událost s názvem eventName. Nejsou provedeny žádné kontroly, abyste zjistili, jestli už listener byla přidána. Více volání, která předávají stejnou kombinaci eventName a listener, způsobí přidání listener a volání několikrát.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

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

Parametry

eventName

string | symbol

Název události.

listener

(args: any[]) => void

Funkce zpětného volání

Návraty

Client

zděděno z InternalClient.prependListener

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

Přidá jednorázovélistener funkce pro událost s názvem eventName do začínající pole naslouchacích procesů. Při příštím spuštění eventName se tento naslouchací proces odebere a potom se vyvolá.

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

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

Parametry

eventName

string | symbol

Název události.

listener

(args: any[]) => void

Funkce zpětného volání

Návraty

Client

zděděno z InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Vrátí kopii pole naslouchacích procesů pro událost s názvem eventName, včetně všech obálky (například těch vytvořených .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<K>(eventName: string | symbol): Function[]

Parametry

eventName

string | symbol

Návraty

Function[]

zděděné z InternalClient.rawListeners

reject(Message) 

function reject(message: Message): Promise<MessageRejected>

Parametry

message
Message

Návraty

Promise<MessageRejected>

zděděno z InternalClient.reject

reject(Message, Callback<MessageRejected>) 

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Parametry

message
Message
rejectCallback

Callback<MessageRejected>

zděděno z InternalClient.reject

removeAllListeners(string | symbol)

Odebere všechny naslouchací procesy nebo naslouchací procesy zadané eventName.

Je vhodné odebrat naslouchací procesy přidané jinde v kódu, zejména pokud byla instance EventEmitter vytvořená nějakou jinou komponentou nebo modulem (např. sokety nebo streamy souborů).

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

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

Parametry

eventName

string | symbol

Návraty

Client

zděděno z InternalClient.removeAllListeners

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

Odebere zadanou listener z pole naslouchacího procesu pro událost s názvem eventName.

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

removeListener() odebere z pole naslouchacího procesu nanejvýš jednu instanci naslouchacího procesu. Pokud byl některý jeden naslouchací proces přidán vícekrát do pole naslouchacího procesu pro zadané eventName, pak removeListener() musí být volána vícekrát, aby bylo možné odebrat každou instanci.

Jakmile se událost vygeneruje, všechny naslouchací procesy, které jsou k ní připojeny v době generování, se volají v pořadí. To znamená, že všechny removeListener() nebo removeAllListeners() volání po vygenerování a před dokončením posledního naslouchacího procesu je neodeberou zemit() probíhajícího. Následné události se chovají podle očekávání.

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

Vzhledem k tomu, že naslouchací procesy se spravují pomocí interního pole, při volání se změní indexy pozice libovolného naslouchacího procesu registrovaného po odebrání naslouchacího procesu. To nebude mít vliv na pořadí, ve kterém se volají naslouchací procesy, ale znamená to, že všechny kopie pole naslouchacího procesu vrácené metodou emitter.listeners() bude potřeba znovu vytvořit.

Když je jedna funkce přidána jako obslužná rutina několikrát pro jednu událost (jako v příkladu níže), removeListener() odebere naposledy přidanou instanci. V příkladu se odebere naslouchací proces once('ping'):

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

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Návraty

Client

zděděno z InternalClient.removeListener

sendEvent(Message) 

function sendEvent(message: Message): Promise<MessageEnqueued>

Parametry

message
Message

Návraty

Promise<MessageEnqueued>

zděděno z InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parametry

message
Message
sendEventCallback

Callback<MessageEnqueued>

zděděno z InternalClient.sendEvent

sendEventBatch(Message[]) 

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parametry

messages

Message[]

Návraty

Promise<MessageEnqueued>

zděděno z InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parametry

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

zděděno z InternalClient.sendEventBatch

setMaxListeners(number)

Ve výchozím nastavení EventEmitters zobrazí upozornění, pokud se pro konkrétní událost přidá více než 10 naslouchací procesy. Toto je užitečné výchozí nastavení, které pomáhá najít nevrácenou paměť. Metoda emitter.setMaxListeners() umožňuje upravit limit pro tuto konkrétní instanci EventEmitter. Hodnotu lze nastavit na Infinity (nebo 0), aby bylo možné označit neomezený počet naslouchacích procesů.

Vrátí odkaz na EventEmitter, aby volání bylo možné zřetězený.

function setMaxListeners(n: number): Client

Parametry

n

number

Návraty

Client

zděděno z InternalClient.setMaxListeners

setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 

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

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Parametry

n

number

Nezáporné číslo. Maximální počet naslouchacích procesů na EventTarget události.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Nula nebo více instancí {EventTarget} nebo {EventEmitter}. Pokud není zadán žádný, n je nastaven jako výchozí maximum pro všechny nově vytvořené objekty {EventTarget} a {EventEmitter}.

zděděno z InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Nastaví zásadu opakování používanou klientem pro všechny operace. Výchozí hodnota je ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parametry

policy

RetryPolicy

{RetryPolicy} Zásady opakování, které by se měly použít pro všechny budoucí operace.

zděděno z InternalClient.setRetryPolicy

setTransportOptions(any) 

function setTransportOptions(options: any): Promise<TransportConfigured>

Parametry

options

any

Návraty

Promise<TransportConfigured>

zděděno z InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parametry

options

any

done

Callback<TransportConfigured>

zděděno z InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parametry

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

zděděno z InternalClient.updateSharedAccessSignature

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest) 

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parametry

error

Error

event

string | symbol

args

AnyRest

zděděno ze InternalClient.__@captureRejectionSymbol@141