ModuleClient class

Pacote:: azure-iot-device

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

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

Extends: InternalClient

Métodos

close()
close(Callback<Disconnected>)	Fecha a conexão de transporte e destrói os recursos do cliente. Nota: 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 a partir do método de autenticação fornecido e usando o tipo de transporte determinado.
fromConnectionString(string, any)	Cria um cliente de dispositivo do Hub IoT a partir 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 uma variável de ambiente chamada `EdgeHubConnectionString` ou `IotHubConnectionString` existir, esse valor será usado e o comportamento será idêntico a chamar `fromConnectionString` passando isso. Se essas variáveis de ambiente não existirem, então as seguintes variáveis DEVEM 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 a partir da 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 do módulo fornecido
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)	Envia uma matriz de eventos para a saída do módulo fornecido
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>)
addListener<E>(string \| symbol, (args: any[]) => void)	Alias para `emitter.on(eventName, listener)`.
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<E>(string \| symbol, any[])	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 teve 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. `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) ]`
getMaxListeners()	Retorna o valor máximo de ouvinte atual para o `EventEmitter` que é definido por `emitter.setMaxListeners(n)` ou padrão como `events.defaultMaxListeners`.
getTwin()
getTwin(Callback<Twin>)
listenerCount<E>(string \| symbol, (args: any[]) => void)	Retorna o número de ouvintes ouvindo o evento chamado `eventName`. Se `listener` for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista dos ouvintes do evento.
listeners<E>(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<E>(string \| symbol, (args: any[]) => void)	Alias para `emitter.removeListener()`.
on<E>(string \| symbol, (args: any[]) => void)	Adiciona a função `listener` ao final da matriz de ouvintes do evento chamado `eventName`. Nenhuma verificação é feita para ver se o `listener` já foi adicionado. Várias chamadas que passam a mesma combinação de `eventName` e `listener` resultarão no `listener` sendo adicionado e chamado 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<E>(string \| symbol, (args: any[]) => void)	Adiciona uma função`listener` única para o evento chamado `eventName`. Na próxima vez que `eventName` for acionado, esse ouvinte será removido e, em seguida, 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<E>(string \| symbol, (args: any[]) => void)	Adiciona a função ao inicial da matriz listeners para o evento chamado . Nenhuma verificação é feita para ver se o `listener` já foi adicionado. Várias chamadas que passam a mesma combinação de `eventName` e `listener` resultarão no `listener` sendo adicionado e chamado 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<E>(string \| symbol, (args: any[]) => void)	Adiciona uma função de única para o evento chamado ao inicial da matriz de ouvintes. Na próxima vez que `eventName` for acionado, esse ouvinte será removido e, em seguida, 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<E>(string \| symbol)	Retorna uma cópia da matriz de ouvintes para o evento chamado `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<E>(string \| symbol)	Remove todos os ouvintes ou os do `eventName`especificado. É uma má prática remover ouvintes adicionados em outro lugar no código, particularmente quando a instância `EventEmitter` foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivos). Retorna uma referência ao `EventEmitter`, para que as chamadas possam ser encadeadas.
removeListener<E>(string \| symbol, (args: any[]) => void)	Remove o `listener` especificado da matriz de ouvinte do 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 ouvinte para o `eventName`especificado, `removeListener()` deverá ser chamado várias vezes para remover cada instância. Uma vez que um evento é emitido, todos os ouvintes ligados a ele no momento da emissão são chamados em ordem. Isto implica que quaisquer `removeListener()` chamadas `removeAllListeners()`de ou após a emissão e antes do último ouvinte terminar a execução não as removerá do `emit()` processo em andamento. Os acontecimentos subsequentes comportam-se como 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 geridos através de um array interno, chamar isto altera os índices de posição de qualquer ouvinte registado após a remoção do ouvinte. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz de ouvintes retornadas pelo método `emitter.listeners()` precisarão ser recriadas. Quando uma única função tiver sido adicionada como 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`EventEmitter`s imprimirá um aviso se mais de `10` ouvintes forem adicionados para um evento específico. Este é um padrão útil que ajuda a encontrar vazamentos de memória. O método `emitter.setMaxListeners()` permite que o limite seja modificado para esta instância `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.
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](Error, string \| symbol, any[])	O `Symbol.for('nodejs.rejection')` método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e `captureRejections` está ativado no emissor. É possível usar `events.captureRejectionSymbol` em vez de `Symbol.for('nodejs.rejection')`. `import { EventEmitter, captureRejectionSymbol } from 'node:events'; class MyClass extends EventEmitter { constructor() { super({ captureRejections: true }); } [captureRejectionSymbol](err, event, ...args) { console.log('rejection happened for', event, 'with', err, ...args); this.destroy(err); } destroy(err) { // Tear the resource down here. } }`

Detalhes de Método

close()

function close(): Promise<Disconnected>

Devoluções

Promise<Disconnected>

close(Callback<Disconnected>)

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

Nota: 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 uma vez que o transporte é desconectado e o cliente fechado.

fromAuthenticationProvider(AuthenticationProvider, any)

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

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.

Devoluções

ModuleClient

fromConnectionString(string, any)

Cria um cliente de dispositivo do Hub IoT a partir 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.

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 do Hub IoT usando informações de configuração do ambiente.

Se uma variável de ambiente chamada EdgeHubConnectionString ou IotHubConnectionString existir, esse valor será usado e o comportamento será idêntico a chamar fromConnectionString passando isso. Se essas variáveis de ambiente não existirem, então as seguintes variáveis DEVEM 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 para invocar 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 a partir da 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

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 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 do dispositivo alvo

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

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á manipulado pelo retorno de chamada

callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

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

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 fornecido

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

Devoluções

Promise<MessageEnqueued>

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

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

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 para chamar quando as operações foram enfileiradas.

setOptions(DeviceClientOptions)

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

Parâmetros

options: DeviceClientOptions

Devoluções

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

A DeviceClientOptions objeto.

done: Callback<TransportConfigured>

Retorno de chamada opcional para chamar uma vez que as opções tenham 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

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

Alias para emitter.on(eventName, listener).

function addListener<E>(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<E>(string | symbol, any[])

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 teve 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<E>(eventName: string | symbol, args: any[]): boolean

Parâmetros

eventName: string | symbol

args: any[]

Devoluções

boolean

herdado de InternalClient.emit

eventNames()

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes.

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

getMaxListeners()

Retorna o valor máximo de ouvinte atual para o EventEmitter que é definido por emitter.setMaxListeners(n) ou padrão como events.defaultMaxListeners.

function getMaxListeners(): number

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

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

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Parâmetros

eventName: string | symbol

O nome do evento que está sendo escutado

listener: (args: any[]) => void

A função de manipulador de eventos

Devoluções

number

herdado de InternalClient.listenerCount

listeners<E>(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<E>(eventName: string | symbol): (args: any[]) => void[]

Parâmetros

eventName: string | symbol

Devoluções

(args: any[]) => void[]

herdado de InternalClient.listeners

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

Alias para emitter.removeListener().

function off<E>(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<E>(string | symbol, (args: any[]) => void)

Adiciona a função listener ao final da matriz de ouvintes do evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas que passam a mesma combinação de eventName e listener resultarão no listener sendo adicionado e chamado 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<E>(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

Devoluções

ModuleClient

herdado de InternalClient.on

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

Adiciona uma funçãolistener única para o evento chamado eventName. Na próxima vez que eventName for acionado, esse ouvinte será removido e, em seguida, 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<E>(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

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

Adiciona a função ao inicial da matriz listeners para o evento chamado . Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas que passam a mesma combinação de eventName e listener resultarão no listener sendo adicionado e chamado 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<E>(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

Devoluções

ModuleClient

herdado de InternalClient.prependListener

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

Adiciona uma função de única para o evento chamado ao inicial da matriz de ouvintes. Na próxima vez que eventName for acionado, esse ouvinte será removido e, em seguida, 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<E>(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

Devoluções

ModuleClient

herdado de InternalClient.prependOnceListener

rawListeners<E>(string | symbol)

Retorna uma cópia da matriz de ouvintes para o evento chamado 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<E>(eventName: string | symbol): (args: any[]) => void[]

Parâmetros

eventName: string | symbol

Devoluções

(args: any[]) => void[]

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<E>(string | symbol)

Remove todos os ouvintes ou os do eventNameespecificado.

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

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

function removeAllListeners<E>(eventName?: string | symbol): ModuleClient

Parâmetros

eventName: string | symbol

Devoluções

ModuleClient

herdado de InternalClient.removeAllListeners

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

Remove o listener especificado da matriz de ouvinte do 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 ouvinte para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Uma vez que um evento é emitido, todos os ouvintes ligados a ele no momento da emissão são chamados em ordem. Isto implica que quaisquer removeListener() chamadas removeAllListeners()de ou após a emissão e antes do último ouvinte terminar a execução não as removerá do emit() processo em andamento. Os acontecimentos subsequentes comportam-se como 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 geridos através de um array interno, chamar isto altera os índices de posição de qualquer ouvinte registado após a remoção do ouvinte. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz de ouvintes retornadas pelo método emitter.listeners() precisarão ser recriadas.

Quando uma única função tiver sido adicionada como 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<E>(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 padrãoEventEmitters imprimirá um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Este é um padrão útil que ajuda a encontrar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância 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

Devoluções

ModuleClient

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

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](Error, string | symbol, any[])

O Symbol.for('nodejs.rejection') método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e captureRejections está ativado no emissor. É possível usar events.captureRejectionSymbol em vez de Symbol.for('nodejs.rejection').

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parâmetros

error: Error

event: string | symbol

args: any[]

Herdado de InternalClient.__@captureRejectionSymbol@127

Partilhar via

ModuleClient class

Métodos

Métodos Herdados

Detalhes de Método

close()

Devoluções

close(Callback<Disconnected>)

Parâmetros

fromAuthenticationProvider(AuthenticationProvider, any)

Parâmetros

Devoluções

fromConnectionString(string, any)

Parâmetros

Devoluções

fromEnvironment(any)

Parâmetros

Devoluções

fromEnvironment(any, Callback<ModuleClient>)

Parâmetros

fromSharedAccessSignature(string, any)

Parâmetros

Devoluções

invokeMethod(string, MethodParams)

Parâmetros

Devoluções

invokeMethod(string, MethodParams, Callback<MethodResult>)

Parâmetros

invokeMethod(string, string, MethodParams)

Parâmetros

Devoluções

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

Parâmetros

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parâmetros

sendOutputEvent(string, Message)

Parâmetros

Devoluções

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Parâmetros

sendOutputEventBatch(string, Message[])

Parâmetros

Devoluções

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

Parâmetros

setOptions(DeviceClientOptions)

Parâmetros

Devoluções

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Parâmetros

Detalhes do Método Herdado

abandon(Message)

Parâmetros

Devoluções

abandon(Message, Callback<MessageAbandoned>)

Parâmetros

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

Parâmetros

Devoluções

complete(Message)

Parâmetros

Devoluções

complete(Message, Callback<MessageCompleted>)

Parâmetros

emit<E>(string | symbol, any[])

Parâmetros

Devoluções

eventNames()

Devoluções

getMaxListeners()

Devoluções

getTwin()

Devoluções

getTwin(Callback<Twin>)

Parâmetros

listenerCount<E>(string | symbol, (args: any[]) => void)

Parâmetros

Devoluções

listeners<E>(string | symbol)

Parâmetros