ModuleClient class

  • Referencia
Paquete:
azure-iot-device

IoT Hub cliente de dispositivo usado para conectar un dispositivo con una instancia de Azure IoT Hub.

Los usuarios del SDK deben llamar a uno de los métodos de fábrica, fromConnectionString o fromSharedAccessSignature para crear un cliente de dispositivo IoT Hub.

Extends

InternalClient

Propiedades heredadas

captureRejections

Valor: booleano

Cambie la opción predeterminada captureRejections en todos los objetos nuevos EventEmitter .
captureRejectionSymbol

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

Vea cómo escribir un personalizado rejection handler.
defaultMaxListeners

De forma predeterminada, se puede registrar un máximo de agentes de 10 escucha para cualquier evento único. Este límite se puede cambiar para instancias individuales EventEmitter mediante el emitter.setMaxListeners(n) método . Para cambiar el valor predeterminado de todas lasEventEmitter instancias, se puede usar la events.defaultMaxListeners propiedad . Si este valor no es un número positivo, se produce una RangeError excepción .

Tenga cuidado al establecer events.defaultMaxListeners porque el cambio afecta a todas lasEventEmitter instancias, incluidas las creadas antes de realizar el cambio. Sin embargo, la llamada emitter.setMaxListeners(n) a sigue teniendo prioridad sobre events.defaultMaxListeners.

Esto no es un límite estricto. La EventEmitter instancia permitirá agregar más agentes de escucha, pero generará una advertencia de seguimiento en stderr que indica que se ha detectado una "posible pérdida de memoria de EventEmitter". Para cualquier único EventEmitter, los emitter.getMaxListeners() métodos y emitter.setMaxListeners() se pueden usar para evitar temporalmente esta advertencia:

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

La --trace-warnings marca de línea de comandos se puede usar para mostrar el seguimiento de la pila para estas advertencias.

La advertencia emitida se puede inspeccionar con process.on('warning') y tendrá las propiedades , typey count adicionalesemitter, que hacen referencia a la instancia del emisor de eventos, el nombre del evento y el número de agentes de escucha adjuntos, respectivamente. Su name propiedad se establece en 'MaxListenersExceededWarning'.
errorMonitor

Este símbolo se usará para instalar un agente de escucha solo para supervisar 'error' eventos. Se llama a los agentes de escucha instalados mediante este símbolo antes de llamar a los agentes de escucha normales 'error' .

La instalación de un agente de escucha mediante este símbolo no cambia el comportamiento una vez que se emite un 'error' evento. Por lo tanto, el proceso se bloqueará si no hay ningún agente de escucha normal 'error' instalado.

Métodos

close()
close(Callback<Disconnected>)

Cierra la conexión de transporte y destruye los recursos del cliente.

Nota: Después de llamar a este método, no se puede reutilizar el objeto ModuleClient.
fromAuthenticationProvider(AuthenticationProvider, any)

Crea un cliente de módulo IoT Hub a partir del método de autenticación especificado y usa el tipo de transporte especificado.
fromConnectionString(string, any)

Crea un cliente de dispositivo IoT Hub a partir del cadena de conexión dado mediante el tipo de transporte especificado.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Crea un cliente de módulo IoT Hub mediante la información de configuración del entorno.

Si existe una variable de entorno denominada EdgeHubConnectionString o IotHubConnectionString existe, ese valor se usa y el comportamiento es idéntico a llamar fromConnectionString a pasarlo. Si esas variables de entorno no existen, se deben definir las siguientes variables:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"
fromSharedAccessSignature(string, any)

Crea un cliente de módulo IoT Hub a partir de la firma de acceso compartido especificada mediante el tipo de transporte especificado.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca un método en un dispositivo de bajada o en otro módulo en el mismo dispositivo IoTEdge. Tenga en cuenta que esta característica solo funciona cuando el módulo se ejecuta como parte de un dispositivo IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registra una devolución de llamada para un método denominado methodName.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envía un evento a la salida del módulo especificado.
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Envía una matriz de eventos a la salida del módulo determinado.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Pasa opciones al ModuleClient objeto que se puede usar para configurar el transporte.

Métodos heredados

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

Escucha una vez al abort evento en el proporcionado signal.

Escuchar el abort evento en las señales de anulación no es seguro y puede provocar pérdidas de recursos, ya que otro tercero con la señal puede llamar a e.stopImmediatePropagation(). Desafortunadamente, Node.js no puede cambiar esto, ya que infringiría el estándar web. Además, la API original facilita la eliminación de agentes de escucha.

Esta API permite usar AbortSignalde forma segura s en Node.js API mediante la resolución de estos dos problemas escuchando el evento de forma que no impide que stopImmediatePropagation el agente de escucha se ejecute.

Devuelve un descartable para que se pueda cancelar la suscripción más fácilmente.

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 para emitter.on(eventName, listener).
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado eventName, en el orden en que se registraron, pasando los argumentos proporcionados a cada uno.

Devuelve true si el evento tenía agentes de escucha; en caso contrario, false .

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

Devuelve una matriz que muestra los eventos para los que el emisor tiene agentes de escucha registrados. Los valores de la matriz son cadenas o 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> | _DOMEventTarget, string | symbol)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName.

Para EventEmitters esto se comporta exactamente igual que llamar a .listeners en el emisor.

Para EventTargets, esta es la única manera de obtener los agentes de escucha de eventos para el destino del evento. Esto es útil para fines de depuración y diagnóstico.

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

Devuelve el valor del agente de escucha máximo actual para el EventEmitter que se establece de emitter.setMaxListeners(n) forma predeterminada en defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Devuelve la cantidad máxima establecida actualmente de agentes de escucha.

Para EventEmitters esto se comporta exactamente igual que llamar a .getMaxListeners en el emisor.

Para EventTargets, esta es la única manera de obtener el número máximo de agentes de escucha de eventos para el destino del evento. Si el número de controladores de eventos en un único eventTarget supera el conjunto máximo, EventTarget imprimirá una advertencia.

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)

Método de clase que devuelve el número de agentes de escucha para el eventName especificado registrado en el especificado 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)

Devuelve el número de agentes de escucha que escuchan el evento denominado eventName. Si listener se proporciona, devolverá cuántas veces se encuentra el agente de escucha en la lista de agentes de escucha del evento.
listeners<K>(string | symbol)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado 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 para emitter.removeListener().
on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions) 
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

Devuelve un AsyncIterator objeto que recorre en iteración eventName los eventos. Se producirá si EventEmitter emite 'error'. Quita todos los agentes de escucha al salir del bucle. El value devuelto por cada iteración es una matriz compuesta por los argumentos de evento emitidos.

Se AbortSignal puede usar para cancelar la espera de eventos:

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

Agrega la listener función al final de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si listener ya se ha agregado . Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que listener se agregue y se llame varias veces.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependListener() método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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)

Crea un Promise objeto que se cumple cuando EventEmitter emite el evento especificado o que se rechaza si EventEmitter emite 'error' mientras espera. Se Promise resolverá con una matriz de todos los argumentos emitidos para el evento especificado.

Este método es genérico intencionadamente y funciona con la interfaz EventTarget de la plataforma web, que no tiene semántica de eventos especiales'error' y no escucha el 'error' evento.

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

El control especial del 'error' evento solo se usa cuando events.once() se usa para esperar a otro evento. Si events.once() se usa para esperar al propio evento 'error' , se trata como cualquier otro tipo de evento sin control especial:

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

Se AbortSignal puede usar para cancelar la espera del evento:

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

Agrega una función únicalistener para el evento denominado eventName. La próxima vez eventName que se desencadena, este agente de escucha se quita y, a continuación, se invoca.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependOnceListener() método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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)

Agrega la listener función al principio de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si listener ya se ha agregado . Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que listener se agregue y se llame varias veces.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Agrega una función únicalistener para el evento denominado eventName al principio de la matriz de agentes de escucha. La próxima vez eventName que se desencadena, se quita este agente de escucha y, a continuación, se invoca.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.
rawListeners<K>(string | symbol)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName, incluidos los contenedores (como los creados por .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)

Quita todos los agentes de escucha o los del especificado eventName.

Es una mala práctica quitar agentes de escucha agregados en otro lugar del código, especialmente cuando la EventEmitter instancia se creó por algún otro componente o módulo (por ejemplo, sockets o secuencias de archivos).

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.
removeListener<K>(string | symbol, (args: any[]) => void)

Quita el especificado listener de la matriz del agente de escucha para el evento denominado eventName.

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

removeListener() quitará, como máximo, una instancia de un agente de escucha de la matriz del agente de escucha. Si se ha agregado un único agente de escucha varias veces a la matriz del agente de escucha para el especificado eventName, removeListener() se debe llamar varias veces para quitar cada instancia.

Una vez emitido un evento, se llama a todos los agentes de escucha adjuntos en el momento de emitir. Esto implica que cualquier removeListener() llamada o removeAllListeners()después de emitir y antes de que el último agente de escucha finalice la ejecución no los quitará deemit() en curso. Los eventos posteriores se comportan según lo previsto.

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

Dado que los agentes de escucha se administran mediante una matriz interna, al llamar a esto se cambiarán los índices de posición de cualquier agente de escucha registrado después de quitar el agente de escucha. Esto no afectará al orden en que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el emitter.listeners() método deberán volver a crearse.

Cuando se ha agregado una sola función como controlador varias veces para un único evento (como en el ejemplo siguiente), removeListener() se quitará la instancia agregada más recientemente. En el ejemplo, se quita el once('ping') agente de escucha:

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

De forma predeterminada EventEmitter, s imprimirá una advertencia si se agregan más 10 de agentes de escucha para un evento determinado. Este es un valor predeterminado útil que ayuda a encontrar fugas de memoria. El emitter.setMaxListeners() método permite modificar el límite para esta instancia específica EventEmitter . El valor se puede establecer en Infinity (o 0) para indicar un número ilimitado de agentes de escucha.

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

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

Establece la directiva de reintento usada por el cliente en todas las operaciones. El valor predeterminado es ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Detalles de las propiedades heredadas

captureRejections

Valor: booleano

Cambie la opción predeterminada captureRejections en todos los objetos nuevos EventEmitter .

static captureRejections: boolean

Valor de propiedad

boolean

Heredado de InternalClient.captureRejections

captureRejectionSymbol

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

Vea cómo escribir un personalizado rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valor de propiedad

typeof captureRejectionSymbol

Heredado de InternalClient.captureRejectionSymbol

defaultMaxListeners

De forma predeterminada, se puede registrar un máximo de agentes de 10 escucha para cualquier evento único. Este límite se puede cambiar para instancias individuales EventEmitter mediante el emitter.setMaxListeners(n) método . Para cambiar el valor predeterminado de todas lasEventEmitter instancias, se puede usar la events.defaultMaxListeners propiedad . Si este valor no es un número positivo, se produce una RangeError excepción .

Tenga cuidado al establecer events.defaultMaxListeners porque el cambio afecta a todas lasEventEmitter instancias, incluidas las creadas antes de realizar el cambio. Sin embargo, la llamada emitter.setMaxListeners(n) a sigue teniendo prioridad sobre events.defaultMaxListeners.

Esto no es un límite estricto. La EventEmitter instancia permitirá agregar más agentes de escucha, pero generará una advertencia de seguimiento en stderr que indica que se ha detectado una "posible pérdida de memoria de EventEmitter". Para cualquier único EventEmitter, los emitter.getMaxListeners() métodos y emitter.setMaxListeners() se pueden usar para evitar temporalmente esta advertencia:

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

La --trace-warnings marca de línea de comandos se puede usar para mostrar el seguimiento de la pila para estas advertencias.

La advertencia emitida se puede inspeccionar con process.on('warning') y tendrá las propiedades , typey count adicionalesemitter, que hacen referencia a la instancia del emisor de eventos, el nombre del evento y el número de agentes de escucha adjuntos, respectivamente. Su name propiedad se establece en 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valor de propiedad

number

Heredado de InternalClient.defaultMaxListeners

errorMonitor

Este símbolo se usará para instalar un agente de escucha solo para supervisar 'error' eventos. Se llama a los agentes de escucha instalados mediante este símbolo antes de llamar a los agentes de escucha normales 'error' .

La instalación de un agente de escucha mediante este símbolo no cambia el comportamiento una vez que se emite un 'error' evento. Por lo tanto, el proceso se bloqueará si no hay ningún agente de escucha normal 'error' instalado.

static errorMonitor: typeof errorMonitor

Valor de propiedad

typeof errorMonitor

Heredado de InternalClient.errorMonitor

Detalles del método

close() 

function close(): Promise<Disconnected>

Devoluciones

Promise<Disconnected>

close(Callback<Disconnected>)

Cierra la conexión de transporte y destruye los recursos del cliente.

Nota: Después de llamar a este método, no se puede reutilizar el objeto ModuleClient.

function close(closeCallback?: Callback<Disconnected>)

Parámetros

closeCallback

Callback<Disconnected>

Función opcional a la que se llamará una vez que se desconecte el transporte y se cierre el cliente.

fromAuthenticationProvider(AuthenticationProvider, any)

Crea un cliente de módulo IoT Hub a partir del método de autenticación especificado y usa el tipo de transporte especificado.

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

Parámetros

authenticationProvider

AuthenticationProvider

Objeto que se usa para obtener los parámetros de autenticación del centro de IoT.

transportCtor

any

Protocolo de transporte que se usa para conectarse a IoT Hub.

Devoluciones

ModuleClient

fromConnectionString(string, any)

Crea un cliente de dispositivo IoT Hub a partir del cadena de conexión dado mediante el tipo de transporte especificado.

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

Parámetros

connStr

string

Un cadena de conexión que encapsula los permisos de "conexión de dispositivos" en un centro de IoT.

transportCtor

any

Constructor de transporte.

Devoluciones

ModuleClient

fromEnvironment(any) 

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Parámetros

transportCtor

any

Devoluciones

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Crea un cliente de módulo IoT Hub mediante la información de configuración del entorno.

Si existe una variable de entorno denominada EdgeHubConnectionString o IotHubConnectionString existe, ese valor se usa y el comportamiento es idéntico a llamar fromConnectionString a pasarlo. Si esas variables de entorno no existen, se deben definir las siguientes variables:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Parámetros

transportCtor

any

Protocolo de transporte que se usa para conectarse a IoT Hub.

callback

Callback<ModuleClient>

Devolución de llamada opcional para invocar cuando se ha construido ModuleClient o si se produce un error al crear el cliente.

fromSharedAccessSignature(string, any)

Crea un cliente de módulo IoT Hub a partir de la firma de acceso compartido especificada mediante el tipo de transporte especificado.

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

Parámetros

sharedAccessSignature

string

Una firma de acceso compartido que encapsula los permisos de "conexión de dispositivo" en un centro de IoT.

transportCtor

any

Devoluciones

ModuleClient

invokeMethod(string, MethodParams) 

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Parámetros

deviceId

string

methodParams

MethodParams

Devoluciones

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca un método en un dispositivo de bajada o en otro módulo en el mismo dispositivo IoTEdge. Tenga en cuenta que esta característica solo funciona cuando el módulo se ejecuta como parte de un dispositivo IoTEdge.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Parámetros

deviceId

string

identificador de dispositivo de destino

methodParams

MethodParams

parámetros de la llamada al método directo

callback

Callback<MethodResult>

devolución de llamada opcional que se invocará con un objeto Error o el resultado de la llamada al método.

invokeMethod(string, string, MethodParams) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Parámetros

deviceId

string

moduleId

string

methodParams

MethodParams

Devoluciones

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Parámetros

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registra una devolución de llamada para un método denominado methodName.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parámetros

methodName

string

Nombre del método que controlará la devolución de llamada.

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Función a la que se llamará cada vez que se reciba una solicitud de método para el método al que se llama methodName .

sendOutputEvent(string, Message) 

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Parámetros

outputName

string

message
Message

Devoluciones

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envía un evento a la salida del módulo especificado.

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Parámetros

outputName

string

Nombre de la salida a la que se va a enviar el evento

message
Message

Mensaje que se va a enviar a la salida especificada

callback

Callback<MessageEnqueued>

Función opcional a la que se llamará cuando se ha puesto en cola la operación.

sendOutputEventBatch(string, Message[]) 

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Parámetros

outputName

string

messages

Message[]

Devoluciones

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Envía una matriz de eventos a la salida del módulo determinado.

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Parámetros

outputName

string

Nombre de la salida a la que se van a enviar los eventos

messages

Message[]

callback

Callback<MessageEnqueued>

Función a la que se llamará cuando se han puesto en cola las operaciones.

setOptions(DeviceClientOptions) 

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

Parámetros

options
DeviceClientOptions

Devoluciones

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Pasa opciones al ModuleClient objeto que se puede usar para configurar el transporte.

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

Parámetros

options
DeviceClientOptions

Objeto DeviceClientOptions .

done

Callback<TransportConfigured>

Devolución de llamada opcional para llamar una vez establecidas las opciones.

Detalles de los métodos heredados

abandon(Message) 

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

Parámetros

message
Message

Devoluciones

Promise<MessageAbandoned>

Heredado de InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

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

Parámetros

message
Message
abandonCallback

Callback<MessageAbandoned>

Heredado de InternalClient.abandon

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

Escucha una vez al abort evento en el proporcionado signal.

Escuchar el abort evento en las señales de anulación no es seguro y puede provocar pérdidas de recursos, ya que otro tercero con la señal puede llamar a e.stopImmediatePropagation(). Desafortunadamente, Node.js no puede cambiar esto, ya que infringiría el estándar web. Además, la API original facilita la eliminación de agentes de escucha.

Esta API permite usar AbortSignalde forma segura s en Node.js API mediante la resolución de estos dos problemas escuchando el evento de forma que no impide que stopImmediatePropagation el agente de escucha se ejecute.

Devuelve un descartable para que se pueda cancelar la suscripción más fácilmente.

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

Parámetros

signal

AbortSignal

resource

(event: Event) => void

Devoluciones

Disposable

Descartable que quita el agente de abort escucha.

Heredado de InternalClient.addAbortListener

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

Alias para emitter.on(eventName, listener).

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

Parámetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluciones

ModuleClient

Heredado de InternalClient.addListener

complete(Message) 

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

Parámetros

message
Message

Devoluciones

Promise<MessageCompleted>

Heredado de InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

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

Parámetros

message
Message
completeCallback

Callback<MessageCompleted>

Heredado de InternalClient.complete

emit<K>(string | symbol, AnyRest)

Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado eventName, en el orden en que se registraron, pasando los argumentos proporcionados a cada uno.

Devuelve true si el evento tenía agentes de escucha; en caso contrario, false .

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

Parámetros

eventName

string | symbol

args

AnyRest

Devoluciones

boolean

Heredado de InternalClient.emit

eventNames()

Devuelve una matriz que muestra los eventos para los que el emisor tiene agentes de escucha registrados. Los valores de la matriz son cadenas o 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)[]

Devoluciones

(string | symbol)[]

Heredado de InternalClient.eventNames

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

Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName.

Para EventEmitters esto se comporta exactamente igual que llamar a .listeners en el emisor.

Para EventTargets, esta es la única manera de obtener los agentes de escucha de eventos para el destino del evento. Esto es útil para fines de depuración y diagnóstico.

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> | _DOMEventTarget, name: string | symbol): Function[]

Parámetros

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

name

string | symbol

Devoluciones

Function[]

Heredado de InternalClient.getEventListeners

getMaxListeners()

Devuelve el valor del agente de escucha máximo actual para el EventEmitter que se establece de emitter.setMaxListeners(n) forma predeterminada en defaultMaxListeners.

function getMaxListeners(): number

Devoluciones

number

Heredado de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Devuelve la cantidad máxima establecida actualmente de agentes de escucha.

Para EventEmitters esto se comporta exactamente igual que llamar a .getMaxListeners en el emisor.

Para EventTargets, esta es la única manera de obtener el número máximo de agentes de escucha de eventos para el destino del evento. Si el número de controladores de eventos en un único eventTarget supera el conjunto máximo, EventTarget imprimirá una advertencia.

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> | _DOMEventTarget): number

Parámetros

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

Devoluciones

number

Heredado de InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Devoluciones

Promise<Twin>

Heredado de InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parámetros

done

Callback<Twin>

Heredado de InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Advertencia

Esta API ya está en desuso.

Since v3.2.0 - Use listenerCount instead.

Método de clase que devuelve el número de agentes de escucha para el eventName especificado registrado en el especificado 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

Parámetros

emitter

EventEmitter<DefaultEventMap>

Emisor al que se va a consultar

eventName

string | symbol

Nombre del evento

Devoluciones

number

Heredado de InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Devuelve el número de agentes de escucha que escuchan el evento denominado eventName. Si listener se proporciona, devolverá cuántas veces se encuentra el agente de escucha en la lista de agentes de escucha del evento.

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

Parámetros

eventName

string | symbol

Nombre del evento que se está escuchando

listener

Function

Función del controlador de eventos

Devoluciones

number

Heredado de InternalClient.listenerCount

listeners<K>(string | symbol)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado 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[]

Parámetros

eventName

string | symbol

Devoluciones

Function[]

Heredado de InternalClient.listeners

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

Alias para emitter.removeListener().

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

Parámetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluciones

ModuleClient

Heredado de InternalClient.off

on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions) 

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

Devuelve un AsyncIterator objeto que recorre en iteración eventName los eventos. Se producirá si EventEmitter emite 'error'. Quita todos los agentes de escucha al salir del bucle. El value devuelto por cada iteración es una matriz compuesta por los argumentos de evento emitidos.

Se AbortSignal puede usar para cancelar la espera de eventos:

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

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>

Parámetros

emitter

EventEmitter<DefaultEventMap>

eventName

string

Nombre del evento que se está escuchando

options

StaticEventEmitterOptions

Devoluciones

AsyncIterableIterator<any>

que AsyncIterator recorre en iteración los eventos emitidos eventName por . emitter

Heredado de InternalClient.on

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

Agrega la listener función al final de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si listener ya se ha agregado . Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que listener se agregue y se llame varias veces.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependListener() método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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

Parámetros

eventName

string | symbol

Nombre del evento.

listener

(args: any[]) => void

Función de devolución de llamada

Devoluciones

ModuleClient

Heredado de InternalClient.on

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

Crea un Promise objeto que se cumple cuando EventEmitter emite el evento especificado o que se rechaza si EventEmitter emite 'error' mientras espera. Se Promise resolverá con una matriz de todos los argumentos emitidos para el evento especificado.

Este método es genérico intencionadamente y funciona con la interfaz EventTarget de la plataforma web, que no tiene semántica de eventos especiales'error' y no escucha el 'error' evento.

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

El control especial del 'error' evento solo se usa cuando events.once() se usa para esperar a otro evento. Si events.once() se usa para esperar al propio evento 'error' , se trata como cualquier otro tipo de evento sin control especial:

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

Se AbortSignal puede usar para cancelar la espera del evento:

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

Parámetros

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Devoluciones

Promise<any[]>

Heredado de InternalClient.once

once(_DOMEventTarget, string, StaticEventEmitterOptions) 

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

Parámetros

emitter

_DOMEventTarget

eventName

string

options

StaticEventEmitterOptions

Devoluciones

Promise<any[]>

Heredado de InternalClient.once

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

Agrega una función únicalistener para el evento denominado eventName. La próxima vez eventName que se desencadena, este agente de escucha se quita y, a continuación, se invoca.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependOnceListener() método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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

Parámetros

eventName

string | symbol

Nombre del evento.

listener

(args: any[]) => void

Función de devolución de llamada

Devoluciones

ModuleClient

Heredado de InternalClient.once

open() 

function open(): Promise<Connected>

Devoluciones

Promise<Connected>

Heredado de InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parámetros

openCallback

Callback<Connected>

Heredado de InternalClient.open

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

Agrega la listener función al principio de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si listener ya se ha agregado . Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que listener se agregue y se llame varias veces.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

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

Parámetros

eventName

string | symbol

Nombre del evento.

listener

(args: any[]) => void

Función de devolución de llamada

Devoluciones

ModuleClient

Heredado de InternalClient.prependListener

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

Agrega una función únicalistener para el evento denominado eventName al principio de la matriz de agentes de escucha. La próxima vez eventName que se desencadena, se quita este agente de escucha y, a continuación, se invoca.

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

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

Parámetros

eventName

string | symbol

Nombre del evento.

listener

(args: any[]) => void

Función de devolución de llamada

Devoluciones

ModuleClient

Heredado de InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName, incluidos los contenedores (como los creados por .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[]

Parámetros

eventName

string | symbol

Devoluciones

Function[]

Heredado de InternalClient.rawListeners

reject(Message) 

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

Parámetros

message
Message

Devoluciones

Promise<MessageRejected>

Heredado de InternalClient.reject

reject(Message, Callback<MessageRejected>) 

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

Parámetros

message
Message
rejectCallback

Callback<MessageRejected>

Heredado de InternalClient.reject

removeAllListeners(string | symbol)

Quita todos los agentes de escucha o los del especificado eventName.

Es una mala práctica quitar agentes de escucha agregados en otro lugar del código, especialmente cuando la EventEmitter instancia se creó por algún otro componente o módulo (por ejemplo, sockets o secuencias de archivos).

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

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

Parámetros

eventName

string | symbol

Devoluciones

ModuleClient

Heredado de InternalClient.removeAllListeners

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

Quita el especificado listener de la matriz del agente de escucha para el evento denominado eventName.

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

removeListener() quitará, como máximo, una instancia de un agente de escucha de la matriz del agente de escucha. Si se ha agregado un único agente de escucha varias veces a la matriz del agente de escucha para el especificado eventName, removeListener() se debe llamar varias veces para quitar cada instancia.

Una vez emitido un evento, se llama a todos los agentes de escucha adjuntos en el momento de emitir. Esto implica que cualquier removeListener() llamada o removeAllListeners()después de emitir y antes de que el último agente de escucha finalice la ejecución no los quitará deemit() en curso. Los eventos posteriores se comportan según lo previsto.

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

Dado que los agentes de escucha se administran mediante una matriz interna, al llamar a esto se cambiarán los índices de posición de cualquier agente de escucha registrado después de quitar el agente de escucha. Esto no afectará al orden en que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el emitter.listeners() método deberán volver a crearse.

Cuando se ha agregado una sola función como controlador varias veces para un único evento (como en el ejemplo siguiente), removeListener() se quitará la instancia agregada más recientemente. En el ejemplo, se quita el once('ping') agente de escucha:

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

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

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

Parámetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluciones

ModuleClient

Heredado de InternalClient.removeListener

sendEvent(Message) 

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

Parámetros

message
Message

Devoluciones

Promise<MessageEnqueued>

Heredado de InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

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

Parámetros

message
Message
sendEventCallback

Callback<MessageEnqueued>

Heredado de InternalClient.sendEvent

sendEventBatch(Message[]) 

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

Parámetros

messages

Message[]

Devoluciones

Promise<MessageEnqueued>

Heredado de InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Parámetros

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

Heredado de InternalClient.sendEventBatch

setMaxListeners(number)

De forma predeterminada EventEmitter, s imprimirá una advertencia si se agregan más 10 de agentes de escucha para un evento determinado. Este es un valor predeterminado útil que ayuda a encontrar fugas de memoria. El emitter.setMaxListeners() método permite modificar el límite para esta instancia específica EventEmitter . El valor se puede establecer en Infinity (o 0) para indicar un número ilimitado de agentes de escucha.

Devuelve una referencia a , EventEmitterpara que las llamadas se puedan encadenar.

function setMaxListeners(n: number): ModuleClient

Parámetros

n

number

Devoluciones

ModuleClient

Heredado de InternalClient.setMaxListeners

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

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

Parámetros

n

number

Número no negativo. Número máximo de agentes de escucha por EventTarget evento.

eventTargets

(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]

Heredado de InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Establece la directiva de reintento usada por el cliente en todas las operaciones. El valor predeterminado es ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parámetros

policy

RetryPolicy

{RetryPolicy} Directiva de reintento que se debe usar para todas las operaciones futuras.

Heredado de InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Parámetros

options

any

Devoluciones

Promise<TransportConfigured>

Heredado de InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

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

Parámetros

options

any

done

Callback<TransportConfigured>

Heredado de InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Parámetros

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Heredado de InternalClient.updateSharedAccessSignature

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

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

Parámetros

error

Error

event

string | symbol

args

AnyRest

Heredado de InternalClient.__@captureRejectionSymbol@138