ModuleClient class

Pacote:
azure-iot-device

Cliente de dispositivo do Hub IoT usado para conectar um dispositivo com um hub IoT do Azure.

Os usuários do SDK devem chamar um dos métodos de fábrica, doConnectionString ou fromSharedAccessSignature para criar um cliente de dispositivo do Hub IoT.

Extends

InternalClient

Propriedades herdadas

captureRejections

Valor: booleano

Mude a opção padrão captureRejections em todos os novos EventEmitter objetos.
captureRejectionSymbol

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

Veja como escrever um arquivo personalizado rejection handler.
defaultMaxListeners

Por padrão, um máximo de 10 ouvintes pode ser registrado para qualquer evento individual. Esse limite pode ser alterado para instâncias individuais EventEmitter usando o emitter.setMaxListeners(n) método. Para alterar o padrão para todasEventEmitter as instâncias, a events.defaultMaxListeners propriedade pode ser usada. Se esse valor não for um número positivo, a RangeError é lançado.

Tenha cuidado ao definir o events.defaultMaxListeners porque a alteração afeta todasEventEmitter as instâncias, incluindo aquelas criadas antes da alteração. No entanto, chamar emitter.setMaxListeners(n) ainda tem precedência sobre events.defaultMaxListeners.

Esse não é um limite rígido. A EventEmitter instância permitirá a adição de mais ouvintes, mas enviará um aviso de rastreamento para stderr indicando que um "possível vazamento de memória EventEmitter" foi detectado. Para qualquer único EventEmitter, os emitter.getMaxListeners() métodos e emitter.setMaxListeners() podem ser usados 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));
});

A --trace-warnings flag de linha de comando pode ser usada para exibir o rastreamento de pilha para tais avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades adicionais emitter, type, e count , referindo-se à instância do emissor do evento, ao nome do evento e ao número de ouvintes conectados, respectivamente. Sua name propriedade é definida como 'MaxListenersExceededWarning'.
errorMonitor

Esse símbolo deve ser usado para instalar um ouvinte apenas para monitoramento 'error' de eventos. Ouvintes instalados usando esse símbolo são chamados antes dos ouvintes regulares 'error' .

Instalar um ouvinte usando esse símbolo não altera o comportamento uma vez que um 'error' evento seja emitido. Portanto, o processo ainda travará se nenhum ouvinte regular 'error' for instalado.

Métodos

close()
close(Callback<Disconnected>)

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

Observação: depois de chamar esse método, o objeto ModuleClient não pode ser reutilizado.
fromAuthenticationProvider(AuthenticationProvider, any)

Cria um cliente de módulo do Hub IoT com base no método de autenticação fornecido e usando o tipo de transporte fornecido.
fromConnectionString(string, any)

Cria um cliente de dispositivo do Hub IoT da cadeia de conexão fornecida usando o tipo de transporte fornecido.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

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

Se houver uma variável de ambiente chamada EdgeHubConnectionString ou IotHubConnectionString, esse valor será usado e o comportamento será idêntico à chamada fromConnectionString passando isso. Se essas variáveis de ambiente não existirem, as seguintes variáveis deverão 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 do Hub IoT com base na assinatura de acesso compartilhado fornecida usando o tipo de transporte fornecido.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca um método em um dispositivo downstream ou em outro módulo no mesmo dispositivo IoTEdge. Observe que esse recurso só funciona quando o módulo está sendo executado como parte de um dispositivo IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

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

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

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

Passa opções para o objeto ModuleClient que pode ser usado para configurar o transporte.

Métodos herdados

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

Ouve uma vez o abort evento no fornecimento signal.

Ouvir o abort evento nos sinais de aborto é inseguro e pode levar a vazamentos de recursos, já que outra terceira parte com o sinal pode chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode mudar isso, pois violaria o padrão da web. Além disso, a API original facilita esquecer de remover ouvintes.

Essa API permite o uso AbortSignalseguro de s em Node.js APIs ao resolver esses dois problemas ao ouvir o evento de modo que stopImmediatePropagation não impeça o ouvinte de executar.

Devolve um descartável para que possa ser cancelado 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)

Chama de forma síncrona cada um dos ouvintes registrados para o evento chamado eventName, na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna true se o evento tiver ouvintes, 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()

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes. Os valores na matriz são cadeias de caracteres 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> | EventTarget, string | symbol)

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName.

Para EventEmitters, isso se comporta exatamente como chamar .listeners o emissor.

Para EventTargets, essa é a única forma de obter os ouvintes do evento para o alvo do evento. Isso é útil para 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()

Retorna o valor máximo atual do ouvinte para o EventEmitter que é definido por emitter.setMaxListeners(n) ou usa como padrão <xref:EventEmitter.defaultMaxListeners>.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retorna a quantidade máxima de ouvintes atualmente definida.

Para EventEmitters, isso se comporta exatamente como chamar .getMaxListeners o emissor.

Para EventTargets, essa é a única forma de obter o máximo de ouvintes para eventos para o alvo do evento. Se o número de handlers de eventos em um único EventTarget exceder o conjunto máximo, o EventTarget 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 retorna o número de ouvintes para o dado eventName registrado no dado 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)

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista de ouvintes do evento.
listeners<K>(string | symbol)

Retorna uma cópia da matriz de ouvintes para o evento chamado 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 | symbol, StaticEventEmitterIteratorOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

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

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

Retorna e AsyncIterator que itera eventName eventos. Ele vai lançar se o EventEmitter emitir 'error'. Ele remove todos os ouvintes ao sair do loop. O value retorno de cada iteração é um array composto pelos argumentos do evento emitido.

An AbortSignal pode ser usado 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());

Use a close opção para especificar um array de nomes de eventos que encerrará a iteração:

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

const ee = new EventEmitter();

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

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

Adiciona a função listener ao final da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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 emite EventEmitter o evento dado ou que é rejeitado se emite EventEmitter'error' enquanto está esperando. O Promise processo será resolvido com um array de todos os argumentos emitidos para o evento dado.

Esse método é intencionalmente genérico e funciona com a interface da plataforma web EventTarget , que não possui 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 tratamento especial do 'error' evento só é usado quando events.once() é usado para esperar por outro evento. Se events.once() for usado para esperar pelo próprio evento 'error' , então ele é tratado como qualquer outro tipo de evento sem tratamento 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

An AbortSignal pode ser usado para cancelar a espera pelo 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(EventTarget, string, StaticEventEmitterOptions)
once<K>(string | symbol, (args: any[]) => void)

Adiciona uma função de única para o evento chamado . Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependOnceListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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 função listener à inicial da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

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

Adiciona uma função de única para o evento chamado à inicial da matriz de ouvintes. Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

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

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName, incluindo quaisquer wrappers (como aqueles 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 ouvintes ou os do eventNameespecificado.

É uma má prática remover ouvintes adicionados em outro lugar no código, especialmente quando a instância de EventEmitter foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivo).

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

Remove o listener especificado da matriz de ouvintes para o evento chamado eventName.

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

removeListener() removerá, no máximo, uma instância de um ouvinte da matriz do ouvinte. Se qualquer ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Depois que um evento é emitido, todos os ouvintes anexados a ele no momento da emissão são chamados em ordem. Isso implica que qualquer removeListener() ou removeAllListeners() chamadas após emitindo e antes de o último ouvinte concluir a execução não os removerá deemit() em andamento. Os eventos subsequentes se comportam conforme o 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

Como os ouvintes são gerenciados usando uma matriz interna, chamar isso alterará os índices de posição de qualquer ouvinte registrado após o ouvinte ser removido. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz do ouvinte, conforme retornado pelo método emitter.listeners(), precisarão ser recriadas.

Quando uma única função tiver sido adicionada como um manipulador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o ouvinte once('ping') é 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');

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

Por padrão, EventEmitterimprimirão um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância de EventEmitter específica. O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

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

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

Detalhes das propriedades herdadas

captureRejections

Valor: booleano

Mude a opção padrão captureRejections em todos os novos EventEmitter objetos.

static captureRejections: boolean

Valor da propriedade

boolean

Herdado de InternalClient.captureRejections

captureRejectionSymbol

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

Veja como escrever um arquivo personalizado rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valor da propriedade

typeof captureRejectionSymbol

Herdado de InternalClient.captureRejectionSymbol

defaultMaxListeners

Por padrão, um máximo de 10 ouvintes pode ser registrado para qualquer evento individual. Esse limite pode ser alterado para instâncias individuais EventEmitter usando o emitter.setMaxListeners(n) método. Para alterar o padrão para todasEventEmitter as instâncias, a events.defaultMaxListeners propriedade pode ser usada. Se esse valor não for um número positivo, a RangeError é lançado.

Tenha cuidado ao definir o events.defaultMaxListeners porque a alteração afeta todasEventEmitter as instâncias, incluindo aquelas criadas antes da alteração. No entanto, chamar emitter.setMaxListeners(n) ainda tem precedência sobre events.defaultMaxListeners.

Esse não é um limite rígido. A EventEmitter instância permitirá a adição de mais ouvintes, mas enviará um aviso de rastreamento para stderr indicando que um "possível vazamento de memória EventEmitter" foi detectado. Para qualquer único EventEmitter, os emitter.getMaxListeners() métodos e emitter.setMaxListeners() podem ser usados 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));
});

A --trace-warnings flag de linha de comando pode ser usada para exibir o rastreamento de pilha para tais avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades adicionais emitter, type, e count , referindo-se à instância do emissor do evento, ao nome do evento e ao número de ouvintes conectados, respectivamente. Sua name propriedade é definida como 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valor da propriedade

number

Herdado de InternalClient.defaultMaxListeners

errorMonitor

Esse símbolo deve ser usado para instalar um ouvinte apenas para monitoramento 'error' de eventos. Ouvintes instalados usando esse símbolo são chamados antes dos ouvintes regulares 'error' .

Instalar um ouvinte usando esse símbolo não altera o comportamento uma vez que um 'error' evento seja emitido. Portanto, o processo ainda travará se nenhum ouvinte regular 'error' for instalado.

static errorMonitor: typeof errorMonitor

Valor da propriedade

typeof errorMonitor

Herdado de InternalClient.errorMonitor

Detalhes do método

close() 

function close(): Promise<Disconnected>

Retornos

Promise<Disconnected>

close(Callback<Disconnected>)

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

Observação: depois de chamar esse método, o objeto ModuleClient não pode ser reutilizado.

function close(closeCallback?: Callback<Disconnected>)

Parâmetros

closeCallback

Callback<Disconnected>

Função opcional para chamar depois que o transporte é desconectado e o cliente fechado.

fromAuthenticationProvider(AuthenticationProvider, any)

Cria um cliente de módulo do Hub IoT com base no método de autenticação fornecido e usando o tipo de transporte fornecido.

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

Parâmetros

authenticationProvider

AuthenticationProvider

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

transportCtor

any

Protocolo de transporte usado para se conectar ao hub IoT.

Retornos

ModuleClient

fromConnectionString(string, any)

Cria um cliente de dispositivo do Hub IoT da cadeia de conexão fornecida usando o tipo de transporte fornecido.

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

Parâmetros

connStr

string

Uma cadeia de conexão que encapsula permissões de "conexão de dispositivo" em um hub IoT.

transportCtor

any

Um construtor de transporte.

Retornos

ModuleClient

fromEnvironment(any) 

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

Parâmetros

transportCtor

any

Retornos

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

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

Se houver uma variável de ambiente chamada EdgeHubConnectionString ou IotHubConnectionString, esse valor será usado e o comportamento será idêntico à chamada fromConnectionString passando isso. Se essas variáveis de ambiente não existirem, as seguintes variáveis deverão 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 usado para se conectar ao hub IoT.

callback

Callback<ModuleClient>

Retorno de chamada opcional a ser invocado quando o ModuleClient tiver sido construído ou se ocorrer um erro durante a criação do cliente.

fromSharedAccessSignature(string, any)

Cria um cliente de módulo do Hub IoT com base na assinatura de acesso compartilhado fornecida usando o tipo de transporte fornecido.

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

Parâmetros

sharedAccessSignature

string

Uma assinatura de acesso compartilhado que encapsula permissões de "conexão de dispositivo" em um hub IoT.

transportCtor

any

Retornos

ModuleClient

invokeMethod(string, MethodParams) 

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

Parâmetros

deviceId

string

methodParams

MethodParams

Retornos

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Invoca um método em um dispositivo downstream ou em outro módulo no mesmo dispositivo IoTEdge. Observe que esse recurso só funciona quando o módulo está sendo 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>

retorno de chamada opcional que será invocado com um objeto Error ou 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

Retornos

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 um retorno de chamada para um método chamado methodName.

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

Parâmetros

methodName

string

Nome do método que será tratado pelo retorno de chamada

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Função que deve ser chamada sempre que uma solicitação de método para o método chamada methodName for recebida.

sendOutputEvent(string, Message) 

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

Parâmetros

outputName

string

message
Message

Retornos

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envia um evento para a saída de módulo fornecida

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

Parâmetros

outputName

string

Nome da saída para a qual enviar o evento

message
Message

Mensagem a ser enviada para a saída fornecida

callback

Callback<MessageEnqueued>

Função opcional para chamar quando a operação tiver sido enfileirada.

sendOutputEventBatch(string, Message[]) 

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

Parâmetros

outputName

string

messages

Message[]

Retornos

Promise<MessageEnqueued>

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

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

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

Parâmetros

outputName

string

Nome da saída para a qual enviar os eventos

messages

Message[]

callback

Callback<MessageEnqueued>

Função a ser chamada quando as operações tiverem sido enfileiradas.

setOptions(DeviceClientOptions) 

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

Parâmetros

options
DeviceClientOptions

Retornos

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Passa opções para o objeto ModuleClient que pode ser usado para configurar o transporte.

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

Parâmetros

options
DeviceClientOptions

Um objeto DeviceClientOptions.

done

Callback<TransportConfigured>

Retorno de chamada opcional para chamar depois que as opções tiverem sido definidas.

Detalhes do método herdado

abandon(Message) 

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

Parâmetros

message
Message

Retornos

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)

Ouve uma vez o abort evento no fornecimento signal.

Ouvir o abort evento nos sinais de aborto é inseguro e pode levar a vazamentos de recursos, já que outra terceira parte com o sinal pode chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode mudar isso, pois violaria o padrão da web. Além disso, a API original facilita esquecer de remover ouvintes.

Essa API permite o uso AbortSignalseguro de s em Node.js APIs ao resolver esses dois problemas ao ouvir o evento de modo que stopImmediatePropagation não impeça o ouvinte de executar.

Devolve um descartável para que possa ser cancelado 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

Retornos

Disposable

Descartável que remove o abort ouvinte.

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

Retornos

ModuleClient

Herdado de InternalClient.addListener

complete(Message) 

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

Parâmetros

message
Message

Retornos

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)

Chama de forma síncrona cada um dos ouvintes registrados para o evento chamado eventName, na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna true se o evento tiver ouvintes, 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

Retornos

boolean

Herdado de InternalClient.emit

eventNames()

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes. Os valores na matriz são cadeias de caracteres 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)[]

Retornos

(string | symbol)[]

Herdado de InternalClient.eventNames

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

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName.

Para EventEmitters, isso se comporta exatamente como chamar .listeners o emissor.

Para EventTargets, essa é a única forma de obter os ouvintes do evento para o alvo do evento. Isso é útil para 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> | EventTarget, name: string | symbol): Function[]

Parâmetros

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Retornos

Function[]

Herdado de InternalClient.getEventListeners

getMaxListeners()

Retorna o valor máximo atual do ouvinte para o EventEmitter que é definido por emitter.setMaxListeners(n) ou usa como padrão <xref:EventEmitter.defaultMaxListeners>.

function getMaxListeners(): number

Retornos

number

herdado de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retorna a quantidade máxima de ouvintes atualmente definida.

Para EventEmitters, isso se comporta exatamente como chamar .getMaxListeners o emissor.

Para EventTargets, essa é a única forma de obter o máximo de ouvintes para eventos para o alvo do evento. Se o número de handlers de eventos em um único EventTarget exceder o conjunto máximo, o EventTarget 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> | EventTarget): number

Parâmetros

emitter

EventEmitter<DefaultEventMap> | EventTarget

Retornos

number

herdado de InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Retornos

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

Essa API foi preterida.

Since v3.2.0 - Use listenerCount instead.

Um método de classe que retorna o número de ouvintes para o dado eventName registrado no dado 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

Retornos

number

Herdado de InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista de ouvintes do evento.

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

Parâmetros

eventName

string | symbol

O nome do evento que está sendo escutado

listener

Function

A função de manipulador de eventos

Retornos

number

Herdado de InternalClient.listenerCount

listeners<K>(string | symbol)

Retorna uma cópia da matriz de ouvintes para o evento chamado 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

Retornos

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

Retornos

ModuleClient

Herdado de InternalClient.off

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

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

const ee = new EventEmitter();

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

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

Retorna e AsyncIterator que itera eventName eventos. Ele vai lançar se o EventEmitter emitir 'error'. Ele remove todos os ouvintes ao sair do loop. O value retorno de cada iteração é um array composto pelos argumentos do evento emitido.

An AbortSignal pode ser usado 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());

Use a close opção para especificar um array de nomes de eventos que encerrará a iteração:

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

const ee = new EventEmitter();

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

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

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

Parâmetros

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Retornos

AsyncIterator<any[], any, any>

E AsyncIterator que itera eventName eventos emitidos pelo emitter

Herdado de InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Parâmetros

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Retornos

AsyncIterator<any[], any, any>

Herdado de InternalClient.on

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

Adiciona a função listener ao final da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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 retorno de chamada

Retornos

ModuleClient

Herdado de InternalClient.on

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

Cria um Promise que é cumprido quando emite EventEmitter o evento dado ou que é rejeitado se emite EventEmitter'error' enquanto está esperando. O Promise processo será resolvido com um array de todos os argumentos emitidos para o evento dado.

Esse método é intencionalmente genérico e funciona com a interface da plataforma web EventTarget , que não possui 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 tratamento especial do 'error' evento só é usado quando events.once() é usado para esperar por outro evento. Se events.once() for usado para esperar pelo próprio evento 'error' , então ele é tratado como qualquer outro tipo de evento sem tratamento 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

An AbortSignal pode ser usado para cancelar a espera pelo 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

Retornos

Promise<any[]>

herdado de InternalClient.once

once(EventTarget, string, StaticEventEmitterOptions) 

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

Parâmetros

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Retornos

Promise<any[]>

herdado de InternalClient.once

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

Adiciona uma função de única para o evento chamado . Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependOnceListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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 retorno de chamada

Retornos

ModuleClient

herdado de InternalClient.once

open() 

function open(): Promise<Connected>

Retornos

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 função listener à inicial da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

Retorna uma referência ao EventEmitter, para que as chamadas 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 retorno de chamada

Retornos

ModuleClient

Herdado de InternalClient.prependListener

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

Adiciona uma função de única para o evento chamado à inicial da matriz de ouvintes. Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

Retorna uma referência ao EventEmitter, para que as chamadas 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 retorno de chamada

Retornos

ModuleClient

Herdado de InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName, incluindo quaisquer wrappers (como aqueles 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

Retornos

Function[]

herdado de InternalClient.rawListeners

reject(Message) 

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

Parâmetros

message
Message

Retornos

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 ouvintes ou os do eventNameespecificado.

É uma má prática remover ouvintes adicionados em outro lugar no código, especialmente quando a instância de EventEmitter foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivo).

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

Retornos

ModuleClient

herdado de InternalClient.removeAllListeners

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

Remove o listener especificado da matriz de ouvintes para o evento chamado eventName.

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

removeListener() removerá, no máximo, uma instância de um ouvinte da matriz do ouvinte. Se qualquer ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Depois que um evento é emitido, todos os ouvintes anexados a ele no momento da emissão são chamados em ordem. Isso implica que qualquer removeListener() ou removeAllListeners() chamadas após emitindo e antes de o último ouvinte concluir a execução não os removerá deemit() em andamento. Os eventos subsequentes se comportam conforme o 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

Como os ouvintes são gerenciados usando uma matriz interna, chamar isso alterará os índices de posição de qualquer ouvinte registrado após o ouvinte ser removido. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz do ouvinte, conforme retornado pelo método emitter.listeners(), precisarão ser recriadas.

Quando uma única função tiver sido adicionada como um manipulador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o ouvinte once('ping') é 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');

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Retornos

ModuleClient

herdado de InternalClient.removeListener

sendEvent(Message) 

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

Parâmetros

message
Message

Retornos

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

Retornos

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 padrão, EventEmitterimprimirão um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância de EventEmitter específica. O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function setMaxListeners(n: number): ModuleClient

Parâmetros

n

number

Retornos

ModuleClient

herdado de InternalClient.setMaxListeners

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

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

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

setMaxListeners(5, target, emitter);

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

Parâmetros

n

number

Um número não negativo. O número máximo de ouvintes por EventTarget evento.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Zero ou mais instâncias de {EventTarget} ou {EventEmitter}. Se nenhum for especificado, n é definido como o máximo padrão para todos os objetos recém-criados {EventTarget} e {EventEmitter}.

herdado de InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Define a política de repetição usada pelo cliente em todas as operações. O padrão é ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parâmetros

policy

RetryPolicy

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

herdado de InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Parâmetros

options

any

Retornos

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@141