ModuleClient class

  • Referência
Pacote:
azure-iot-device

Hub IoT cliente de dispositivo utilizado para ligar um dispositivo a um hub IoT do Azure.

Os utilizadores do SDK devem chamar um dos métodos de fábrica, deConnectionString ou deSharedAccessSignature para criar um cliente de dispositivo Hub IoT.

Extends

InternalClient

Propriedades Herdadas

captureRejections

Valor: booleano

Altere a opção predefinida captureRejections em todos os novos EventEmitter objetos.
captureRejectionSymbol

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

Veja como escrever um .rejection handler
defaultMaxListeners

Por predefinição, um máximo de serviços de 10 escuta pode ser registado em qualquer evento individual. Este limite pode ser alterado para instâncias individuais EventEmitter com o emitter.setMaxListeners(n) método . Para alterar a predefinição para todas asEventEmitter instâncias, a events.defaultMaxListeners propriedade pode ser utilizada. Se este valor não for um número positivo, é emitido um RangeError .

Tenha cuidado ao definir o events.defaultMaxListeners porque a alteração afeta todas asEventEmitter instâncias, incluindo as criadas antes de a alteração ser efetuada. No entanto, as chamadas emitter.setMaxListeners(n) ainda têm precedência sobre events.defaultMaxListeners.

Este não é um limite difícil. A EventEmitter instância permitirá a adição de mais serviços de escuta, mas irá enviar um aviso de rastreio para stderr que indica que foi detetada uma "possível fuga de memória eventEmitter". Para qualquer , EventEmitteros emitter.getMaxListeners() métodos e emitter.setMaxListeners() podem ser utilizados para evitar temporariamente este aviso:

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

O --trace-warnings sinalizador da linha de comandos pode ser utilizado para apresentar o rastreio da pilha para tais avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades adicionais emitter, typee count , referindo-se à instância do emissor de eventos, ao nome do evento e ao número de serviços de escuta anexados, respetivamente. A name propriedade está definida como 'MaxListenersExceededWarning'.
errorMonitor

Este símbolo deve ser utilizado para instalar um serviço de escuta apenas para eventos de monitorização 'error' . Os serviços de escuta instalados com este símbolo são chamados antes de os serviços de escuta regulares 'error' serem chamados.

Instalar um serviço de escuta com este símbolo não altera o comportamento depois de um 'error' evento ser emitido. Por conseguinte, o processo continuará a falhar se não estiver instalado nenhum serviço de escuta normal 'error' .

Métodos

close()
close(Callback<Disconnected>)

Fecha a ligação de transporte e destrói os recursos do cliente.

Nota: depois de chamar este método, não é possível reutilizar o objeto ModuleClient.
fromAuthenticationProvider(AuthenticationProvider, any)

Cria um cliente de módulo Hub IoT a partir do método de autenticação especificado e com o tipo de transporte especificado.
fromConnectionString(string, any)

Cria um cliente de dispositivo Hub IoT a partir do cadeia de ligação especificado com o tipo de transporte especificado.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Cria um cliente de módulo Hub IoT com as informações de configuração do ambiente.

Se uma variável de ambiente denominada EdgeHubConnectionString ou IotHubConnectionString existir, esse valor é utilizado e o comportamento é idêntico à chamada fromConnectionString de transmissão. Se essas variáveis de ambiente não existirem, as seguintes variáveis têm de ser definidas:

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

Cria um cliente de módulo Hub IoT a partir da assinatura de acesso partilhado fornecida com o tipo de transporte especificado.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca um método num dispositivo a jusante ou noutro módulo no mesmo dispositivo IoTEdge. Tenha em atenção que esta funcionalidade só funciona quando o módulo está a ser executado como parte de um dispositivo IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Regista uma chamada de retorno para um método chamado methodName.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envia um evento para a saída do módulo especificado
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Envia uma matriz de eventos para a saída do módulo especificado
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Transmite opções para o ModuleClient objeto que pode ser utilizado para configurar o transporte.

Métodos Herdados

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

Escuta uma vez o abort evento no fornecido signal.

Ouvir o abort evento em sinais de aborto não é seguro e pode levar a fugas de recursos, uma vez que outros terceiros com o sinal podem chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode alterar esta situação, uma vez que violaria o padrão Web. Além disso, a API original facilita a remoção de serviços de escuta.

Esta API permite utilizar AbortSignals em segurança nas APIs Node.js ao resolver estes dois problemas ao ouvir o evento de forma a stopImmediatePropagation não impedir que o serviço de escuta seja executado.

Devolve um descartável para que possa ser anulada a subscrição de mais facilmente.

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)

Liga síncronamente a cada um dos serviços de escuta registados para o evento com o nome eventName, pela ordem em que foram registados, transmitindo os argumentos fornecidos a cada um.

Devolve true se o evento tiver serviços de escuta, false caso contrário.

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

Devolve uma matriz que lista os eventos para os quais o emissor registou serviços de escuta. Os valores na matriz são cadeias ou 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)

Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName.

Para EventEmitters isto tem exatamente o mesmo comportamento que chamar .listeners o emissor.

Para EventTargets, esta é a única forma de obter os serviços de escuta do evento para o destino do evento. Isto é útil para fins de depuração e 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()

Devolve o valor máximo do serviço de escuta atual para o EventEmitter que está definido por emitter.setMaxListeners(n) ou predefinição para DefaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Devolve a quantidade máxima de serviços de escuta atualmente definida.

Para EventEmitters isto tem exatamente o mesmo comportamento que chamar .getMaxListeners o emissor.

Para EventTargets, esta é a única forma de obter os serviços de escuta de eventos máximos para o destino do evento. Se o número de processadores de eventos num único EventTarget exceder o conjunto máximo, o EventTarget irá imprimir um aviso.

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)

Um método de classe que devolve o número de serviços de escuta do dado eventName registado no determinado 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)

Devolve o número de serviços de escuta que escutam o evento com o nome eventName. Se listener for fornecido, devolverá quantas vezes o serviço de escuta é encontrado na lista dos serviços de escuta do evento.
listeners<K>(string | symbol)

Devolve uma cópia da matriz de serviços de escuta do evento com o nome 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

Devolve um AsyncIterator que itera eventos eventName . Será lançado se o EventEmitter emitir 'error'. Remove todos os serviços de escuta ao sair do ciclo. O value devolvido por cada iteração é uma matriz composta pelos argumentos de evento emitidos.

Pode AbortSignal utilizar um para cancelar a 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)

Adiciona a listener função ao fim da matriz de serviços de escuta do evento denominado eventName. Não são efetuadas verificações para ver se o listener já foi adicionado. Várias chamadas que transmitem a mesma combinação de eventName e listener resultarão na adição listener e chamadas múltiplas vezes.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependListener() método pode ser utilizado como uma alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.

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)

Cria um Promise que é cumprido quando EventEmitter emite o evento especificado ou que é rejeitado se o EventEmitter emitir 'error' enquanto aguarda. O Promise será resolvido com uma matriz de todos os argumentos emitidos para o evento especificado.

Este método é intencionalmente genérico e funciona com a interface EventTarget da plataforma Web, que não tem semântica de eventos especiais'error' e não ouve o '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);
}

O processamento especial do 'error' evento só é utilizado quando events.once() é utilizado para aguardar por outro evento. Se events.once() for utilizado para aguardar pelo evento emerror' si, será tratado como qualquer outro tipo de evento sem processamento 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

Pode AbortSignal ser utilizado um para cancelar a espera do 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)

Adiciona uma função únicalistener para o evento com o nome eventName. Da próxima vez eventName que for acionado, este serviço de escuta é removido e, em seguida, invocado.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependOnceListener() método pode ser utilizado como uma alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.

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)

Adiciona a listener função ao início da matriz de serviços de escuta para o evento com o nome eventName. Não são efetuadas verificações para ver se o listener já foi adicionado. Várias chamadas que transmitem a mesma combinação de eventName e listener resultarão na adição listener e chamadas múltiplas vezes.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Adiciona uma função únicalistener para o evento com o nome eventName para o início da matriz de serviços de escuta. Da próxima vez eventName que for acionado, este serviço de escuta é removido e, em seguida, invocado.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.
rawListeners<K>(string | symbol)

Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName, incluindo quaisquer wrappers (como os criados 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)

Remove todos os serviços de escuta ou os dos especificados eventName.

É uma má prática remover os serviços de escuta adicionados noutros locais do código, especialmente quando a EventEmitter instância foi criada por outro componente ou módulo (por exemplo, sockets ou fluxos de ficheiros).

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.
removeListener<K>(string | symbol, (args: any[]) => void)

Remove o especificado listener da matriz do serviço de escuta do evento com o nome eventName.

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

removeListener() irá remover, no máximo, uma instância de um serviço de escuta da matriz do serviço de escuta. Se um único serviço de escuta tiver sido adicionado várias vezes à matriz do serviço de escuta para o especificado eventName, tem de removeListener() ser chamado várias vezes para remover cada instância.

Assim que um evento for emitido, todos os serviços de escuta anexados ao mesmo no momento da emissão são chamados por ordem. Isto implica que qualquer removeListener() ou removeAllListeners()chamadas após emitir e antes da última execução do serviço de escuta não as removerá ememit() curso. Os eventos subsequentes comportam-se conforme esperado.

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

Uma vez que os serviços de escuta são geridos através de uma matriz interna, chamar isto irá alterar os índices de posição de qualquer serviço de escuta registado após a remoção do serviço de escuta. Isto não afetará a ordem pela qual os serviços de escuta são chamados, mas significa que todas as cópias da matriz do serviço de escuta, conforme devolvido pelo emitter.listeners() método, terão de ser recriadas.

Quando uma única função tiver sido adicionada como processador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o once('ping') serviço de escuta é removido:

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Por predefinição EventEmitter, s irá imprimir um aviso se mais do que 10 os serviços de escuta forem adicionados para um evento específico. Esta é uma predefinição útil que ajuda a encontrar fugas de memória. O emitter.setMaxListeners() método permite que o limite seja modificado para esta instância específica EventEmitter . O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de serviços de escuta.

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.
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)

Define a política de repetição utilizada pelo cliente em todas as operações. A predefinição é ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Detalhes da Propriedade Herdada

captureRejections

Valor: booleano

Altere a opção predefinida captureRejections em todos os novos EventEmitter objetos.

static captureRejections: boolean

Valor de Propriedade

boolean

Herdado de InternalClient.captureRejections

captureRejectionSymbol

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

Veja como escrever um .rejection handler

static captureRejectionSymbol: typeof captureRejectionSymbol

Valor de Propriedade

typeof captureRejectionSymbol

Herdado de InternalClient.captureRejectionSymbol

defaultMaxListeners

Por predefinição, um máximo de serviços de 10 escuta pode ser registado em qualquer evento individual. Este limite pode ser alterado para instâncias individuais EventEmitter com o emitter.setMaxListeners(n) método . Para alterar a predefinição para todas asEventEmitter instâncias, a events.defaultMaxListeners propriedade pode ser utilizada. Se este valor não for um número positivo, é emitido um RangeError .

Tenha cuidado ao definir o events.defaultMaxListeners porque a alteração afeta todas asEventEmitter instâncias, incluindo as criadas antes de a alteração ser efetuada. No entanto, as chamadas emitter.setMaxListeners(n) ainda têm precedência sobre events.defaultMaxListeners.

Este não é um limite difícil. A EventEmitter instância permitirá a adição de mais serviços de escuta, mas irá enviar um aviso de rastreio para stderr que indica que foi detetada uma "possível fuga de memória eventEmitter". Para qualquer , EventEmitteros emitter.getMaxListeners() métodos e emitter.setMaxListeners() podem ser utilizados para evitar temporariamente este aviso:

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

O --trace-warnings sinalizador da linha de comandos pode ser utilizado para apresentar o rastreio da pilha para tais avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades adicionais emitter, typee count , referindo-se à instância do emissor de eventos, ao nome do evento e ao número de serviços de escuta anexados, respetivamente. A name propriedade está definida como 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valor de Propriedade

number

Herdado de InternalClient.defaultMaxListeners

errorMonitor

Este símbolo deve ser utilizado para instalar um serviço de escuta apenas para eventos de monitorização 'error' . Os serviços de escuta instalados com este símbolo são chamados antes de os serviços de escuta regulares 'error' serem chamados.

Instalar um serviço de escuta com este símbolo não altera o comportamento depois de um 'error' evento ser emitido. Por conseguinte, o processo continuará a falhar se não estiver instalado nenhum serviço de escuta normal 'error' .

static errorMonitor: typeof errorMonitor

Valor de Propriedade

typeof errorMonitor

Herdado de InternalClient.errorMonitor

Detalhes de Método

close() 

function close(): Promise<Disconnected>

Devoluções

Promise<Disconnected>

close(Callback<Disconnected>)

Fecha a ligação de transporte e destrói os recursos do cliente.

Nota: depois de chamar este método, não é possível reutilizar o objeto ModuleClient.

function close(closeCallback?: Callback<Disconnected>)

Parâmetros

closeCallback

Callback<Disconnected>

Função opcional para chamar assim que o transporte estiver desligado e o cliente fechado.

fromAuthenticationProvider(AuthenticationProvider, any)

Cria um cliente de módulo Hub IoT a partir do método de autenticação especificado e com o tipo de transporte especificado.

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

Parâmetros

authenticationProvider

AuthenticationProvider

Objeto utilizado para obter os parâmetros de autenticação do hub IoT.

transportCtor

any

Protocolo de transporte utilizado para ligar ao hub IoT.

Devoluções

ModuleClient

fromConnectionString(string, any)

Cria um cliente de dispositivo Hub IoT a partir do cadeia de ligação especificado com o tipo de transporte especificado.

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

Parâmetros

connStr

string

Uma cadeia de ligação que encapsula as permissões de "ligação do dispositivo" num hub IoT.

transportCtor

any

Um construtor de transportes.

Devoluções

ModuleClient

fromEnvironment(any) 

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

Parâmetros

transportCtor

any

Devoluções

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Cria um cliente de módulo Hub IoT com as informações de configuração do ambiente.

Se uma variável de ambiente denominada EdgeHubConnectionString ou IotHubConnectionString existir, esse valor é utilizado e o comportamento é idêntico à chamada fromConnectionString de transmissão. Se essas variáveis de ambiente não existirem, as seguintes variáveis têm de ser definidas:

- 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 utilizado para ligar ao hub IoT.

callback

Callback<ModuleClient>

Chamada de retorno opcional para invocar quando o ModuleClient foi construído ou se ocorrer um erro ao criar o cliente.

fromSharedAccessSignature(string, any)

Cria um cliente de módulo Hub IoT a partir da assinatura de acesso partilhado fornecida com o tipo de transporte especificado.

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

Parâmetros

sharedAccessSignature

string

Uma assinatura de acesso partilhado que encapsula permissões de "ligação do dispositivo" num hub IoT.

transportCtor

any

Devoluções

ModuleClient

invokeMethod(string, MethodParams) 

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

Parâmetros

deviceId

string

methodParams

MethodParams

Devoluções

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca um método num dispositivo a jusante ou noutro módulo no mesmo dispositivo IoTEdge. Tenha em atenção que esta funcionalidade só funciona quando o módulo está a ser executado como parte de um dispositivo IoTEdge.

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

Parâmetros

deviceId

string

identificador de dispositivo de destino

methodParams

MethodParams

parâmetros da chamada de método direto

callback

Callback<MethodResult>

chamada de retorno opcional que será invocada com um objeto de erro ou com o resultado da chamada de método.

invokeMethod(string, string, MethodParams) 

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

Parâmetros

deviceId

string

moduleId

string

methodParams

MethodParams

Devoluções

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

Regista uma chamada de retorno para um método chamado methodName.

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

Parâmetros

methodName

string

Nome do método que será processado pela chamada de retorno

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Função que deve ser chamada sempre que for recebido um pedido de método para o método denominado methodName .

sendOutputEvent(string, Message) 

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

Parâmetros

outputName

string

message
Message

Devoluções

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envia um evento para a saída do módulo especificado

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

Parâmetros

outputName

string

Nome da saída para o qual enviar o evento

message
Message

Mensagem para enviar para o resultado especificado

callback

Callback<MessageEnqueued>

Função opcional para chamar quando a operação tiver sido colocado em fila.

sendOutputEventBatch(string, Message[]) 

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

Parâmetros

outputName

string

messages

Message[]

Devoluções

Promise<MessageEnqueued>

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

Envia uma matriz de eventos para a saída do módulo especificado

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

Parâmetros

outputName

string

Nome da saída para enviar os eventos para

messages

Message[]

callback

Callback<MessageEnqueued>

Função a chamar quando as operações tiverem sido colocados em fila.

setOptions(DeviceClientOptions) 

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

Parâmetros

options
DeviceClientOptions

Devoluções

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Transmite opções para o ModuleClient objeto que pode ser utilizado para configurar o transporte.

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

Parâmetros

options
DeviceClientOptions

Um objeto DeviceClientOptions .

done

Callback<TransportConfigured>

Chamada de retorno opcional para ligar assim que as opções tiverem sido definidas.

Detalhes do Método Herdado

abandon(Message) 

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

Parâmetros

message
Message

Devoluções

Promise<MessageAbandoned>

Herdado de InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

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

Parâmetros

message
Message
abandonCallback

Callback<MessageAbandoned>

Herdado de InternalClient.abandon

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

Escuta uma vez o abort evento no fornecido signal.

Ouvir o abort evento em sinais de aborto não é seguro e pode levar a fugas de recursos, uma vez que outros terceiros com o sinal podem chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode alterar esta situação, uma vez que violaria o padrão Web. Além disso, a API original facilita a remoção de serviços de escuta.

Esta API permite utilizar AbortSignals em segurança nas APIs Node.js ao resolver estes dois problemas ao ouvir o evento de forma a stopImmediatePropagation não impedir que o serviço de escuta seja executado.

Devolve um descartável para que possa ser anulada a subscrição de mais facilmente.

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

Devoluções

Disposable

Descartável que remove o abort serviço de escuta.

Herdado 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

Devoluções

ModuleClient

Herdado de InternalClient.addListener

complete(Message) 

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

Parâmetros

message
Message

Devoluções

Promise<MessageCompleted>

Herdado de InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

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

Parâmetros

message
Message
completeCallback

Callback<MessageCompleted>

Herdado de InternalClient.complete

emit<K>(string | symbol, AnyRest)

Liga síncronamente a cada um dos serviços de escuta registados para o evento com o nome eventName, pela ordem em que foram registados, transmitindo os argumentos fornecidos a cada um.

Devolve true se o evento tiver serviços de escuta, false caso contrário.

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

Devoluções

boolean

Herdado de InternalClient.emit

eventNames()

Devolve uma matriz que lista os eventos para os quais o emissor registou serviços de escuta. Os valores na matriz são cadeias ou 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)[]

Devoluções

(string | symbol)[]

Herdado de InternalClient.eventNames

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

Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName.

Para EventEmitters isto tem exatamente o mesmo comportamento que chamar .listeners o emissor.

Para EventTargets, esta é a única forma de obter os serviços de escuta do evento para o destino do evento. Isto é útil para fins de depuração e 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

Devoluções

Function[]

Herdado de InternalClient.getEventListeners

getMaxListeners()

Devolve o valor máximo do serviço de escuta atual para o EventEmitter que está definido por emitter.setMaxListeners(n) ou predefinição para DefaultMaxListeners.

function getMaxListeners(): number

Devoluções

number

Herdado de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Devolve a quantidade máxima de serviços de escuta atualmente definida.

Para EventEmitters isto tem exatamente o mesmo comportamento que chamar .getMaxListeners o emissor.

Para EventTargets, esta é a única forma de obter os serviços de escuta de eventos máximos para o destino do evento. Se o número de processadores de eventos num único EventTarget exceder o conjunto máximo, o EventTarget irá imprimir um aviso.

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

Devoluções

number

Herdado de InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Devoluções

Promise<Twin>

Herdado de InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parâmetros

done

Callback<Twin>

Herdado de InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Aviso

Esta API foi preterida.

Since v3.2.0 - Use listenerCount instead.

Um método de classe que devolve o número de serviços de escuta do dado eventName registado no determinado 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>

O emissor a consultar

eventName

string | symbol

O nome do evento

Devoluções

number

Herdado de InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Devolve o número de serviços de escuta que escutam o evento com o nome eventName. Se listener for fornecido, devolverá quantas vezes o serviço de escuta é encontrado na lista dos serviços de escuta do evento.

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

Parâmetros

eventName

string | symbol

O nome do evento que está a ser escutado

listener

Function

A função de processador de eventos

Devoluções

number

Herdado de InternalClient.listenerCount

listeners<K>(string | symbol)

Devolve uma cópia da matriz de serviços de escuta do evento com o nome 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

Devoluções

Function[]

Herdado 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

Devoluções

ModuleClient

Herdado 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

Devolve um AsyncIterator que itera eventos eventName . Será lançado se o EventEmitter emitir 'error'. Remove todos os serviços de escuta ao sair do ciclo. O value devolvido por cada iteração é uma matriz composta pelos argumentos de evento emitidos.

Pode AbortSignal utilizar um para cancelar a 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

O nome do evento que está a ser escutado

options

StaticEventEmitterOptions

Devoluções

AsyncIterableIterator<any>

Um AsyncIterator que itera eventos emitidos eventName pelo emitter

Herdado de InternalClient.on

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

Adiciona a listener função ao fim da matriz de serviços de escuta do evento denominado eventName. Não são efetuadas verificações para ver se o listener já foi adicionado. Várias chamadas que transmitem a mesma combinação de eventName e listener resultarão na adição listener e chamadas múltiplas vezes.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependListener() método pode ser utilizado como uma alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.

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

O nome do evento.

listener

(args: any[]) => void

A função de chamada de retorno

Devoluções

ModuleClient

Herdado de InternalClient.on

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

Cria um Promise que é cumprido quando EventEmitter emite o evento especificado ou que é rejeitado se o EventEmitter emitir 'error' enquanto aguarda. O Promise será resolvido com uma matriz de todos os argumentos emitidos para o evento especificado.

Este método é intencionalmente genérico e funciona com a interface EventTarget da plataforma Web, que não tem semântica de eventos especiais'error' e não ouve o '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);
}

O processamento especial do 'error' evento só é utilizado quando events.once() é utilizado para aguardar por outro evento. Se events.once() for utilizado para aguardar pelo evento emerror' si, será tratado como qualquer outro tipo de evento sem processamento 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

Pode AbortSignal ser utilizado um para cancelar a espera do 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

Devoluções

Promise<any[]>

Herdado 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

Devoluções

Promise<any[]>

Herdado de InternalClient.once

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

Adiciona uma função únicalistener para o evento com o nome eventName. Da próxima vez eventName que for acionado, este serviço de escuta é removido e, em seguida, invocado.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependOnceListener() método pode ser utilizado como uma alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.

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

O nome do evento.

listener

(args: any[]) => void

A função de chamada de retorno

Devoluções

ModuleClient

Herdado de InternalClient.once

open() 

function open(): Promise<Connected>

Devoluções

Promise<Connected>

Herdado de InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parâmetros

openCallback

Callback<Connected>

Herdado de InternalClient.open

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

Adiciona a listener função ao início da matriz de serviços de escuta para o evento com o nome eventName. Não são efetuadas verificações para ver se o listener já foi adicionado. Várias chamadas que transmitem a mesma combinação de eventName e listener resultarão na adição listener e chamadas múltiplas vezes.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de chamada de retorno

Devoluções

ModuleClient

Herdado de InternalClient.prependListener

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

Adiciona uma função únicalistener para o evento com o nome eventName para o início da matriz de serviços de escuta. Da próxima vez eventName que for acionado, este serviço de escuta é removido e, em seguida, invocado.

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de chamada de retorno

Devoluções

ModuleClient

Herdado de InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName, incluindo quaisquer wrappers (como os criados 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

Devoluções

Function[]

Herdado de InternalClient.rawListeners

reject(Message) 

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

Parâmetros

message
Message

Devoluções

Promise<MessageRejected>

Herdado de InternalClient.reject

reject(Message, Callback<MessageRejected>) 

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

Parâmetros

message
Message
rejectCallback

Callback<MessageRejected>

Herdado de InternalClient.reject

removeAllListeners(string | symbol)

Remove todos os serviços de escuta ou os dos especificados eventName.

É uma má prática remover os serviços de escuta adicionados noutros locais do código, especialmente quando a EventEmitter instância foi criada por outro componente ou módulo (por exemplo, sockets ou fluxos de ficheiros).

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

Devoluções

ModuleClient

Herdado de InternalClient.removeAllListeners

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

Remove o especificado listener da matriz do serviço de escuta do evento com o nome eventName.

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

removeListener() irá remover, no máximo, uma instância de um serviço de escuta da matriz do serviço de escuta. Se um único serviço de escuta tiver sido adicionado várias vezes à matriz do serviço de escuta para o especificado eventName, tem de removeListener() ser chamado várias vezes para remover cada instância.

Assim que um evento for emitido, todos os serviços de escuta anexados ao mesmo no momento da emissão são chamados por ordem. Isto implica que qualquer removeListener() ou removeAllListeners()chamadas após emitir e antes da última execução do serviço de escuta não as removerá ememit() curso. Os eventos subsequentes comportam-se conforme esperado.

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

Uma vez que os serviços de escuta são geridos através de uma matriz interna, chamar isto irá alterar os índices de posição de qualquer serviço de escuta registado após a remoção do serviço de escuta. Isto não afetará a ordem pela qual os serviços de escuta são chamados, mas significa que todas as cópias da matriz do serviço de escuta, conforme devolvido pelo emitter.listeners() método, terão de ser recriadas.

Quando uma única função tiver sido adicionada como processador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o once('ping') serviço de escuta é removido:

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

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

ModuleClient

Herdado de InternalClient.removeListener

sendEvent(Message) 

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

Parâmetros

message
Message

Devoluções

Promise<MessageEnqueued>

Herdado de InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

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

Parâmetros

message
Message
sendEventCallback

Callback<MessageEnqueued>

Herdado de InternalClient.sendEvent

sendEventBatch(Message[]) 

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

Parâmetros

messages

Message[]

Devoluções

Promise<MessageEnqueued>

Herdado de InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Parâmetros

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

Herdado de InternalClient.sendEventBatch

setMaxListeners(number)

Por predefinição EventEmitter, s irá imprimir um aviso se mais do que 10 os serviços de escuta forem adicionados para um evento específico. Esta é uma predefinição útil que ajuda a encontrar fugas de memória. O emitter.setMaxListeners() método permite que o limite seja modificado para esta instância específica EventEmitter . O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de serviços de escuta.

Devolve uma referência ao , para que as EventEmitterchamadas possam ser encadeadas.

function setMaxListeners(n: number): ModuleClient

Parâmetros

n

number

Devoluções

ModuleClient

Herdado 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

Um número não negativo. O número máximo de serviços de escuta por EventTarget evento.

eventTargets

(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]

Herdado de InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Define a política de repetição utilizada pelo cliente em todas as operações. A predefinição é ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parâmetros

policy

RetryPolicy

{RetryPolicy} A política de repetição que deve ser utilizada para todas as operações futuras.

Herdado de InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Parâmetros

options

any

Devoluções

Promise<TransportConfigured>

Herdado de InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

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

Parâmetros

options

any

done

Callback<TransportConfigured>

Herdado de InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Parâmetros

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Herdado 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

Herdado de InternalClient.__@captureRejectionSymbol@138