Compartilhar via

Client class

  • Referência
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, fromConnectionString ou fromSharedAccessSignature para criar um cliente de dispositivo do Hub IoT.

Extends

InternalClient

Construtores

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Propriedades herdadas

captureRejections

Valor: booliano

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

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

Veja como escrever um personalizado rejection handler.
defaultMaxListeners

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

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

Este não é um limite difícil. A EventEmitter instância permitirá que mais ouvintes sejam adicionados, mas gerará 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));
});

O --trace-warnings sinalizador de linha de comando pode ser usado para exibir o rastreamento de pilha para esses avisos.

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

Esse símbolo deve ser usado para instalar um ouvinte somente para eventos de monitoramento 'error' . Os ouvintes instalados usando esse símbolo são chamados antes que os ouvintes regulares 'error' sejam chamados.

Instalar um ouvinte usando esse símbolo não altera o comportamento depois que um 'error' evento é emitido. Portanto, o processo ainda falhará se nenhum ouvinte regular 'error' estiver 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 Client não pode ser reutilizado.
fromAuthenticationProvider(AuthenticationProvider, any)

Cria um cliente de dispositivo 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.
fromSharedAccessSignature(string, any)

Cria um cliente de dispositivo do Hub IoT com base na assinatura de acesso compartilhado fornecida usando o tipo de transporte fornecido.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)

O getBlobSharedAccessSignature obtém o token SAS da conta de armazenamento vinculada do Hub IoT
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

O notifyBlobUploadStatus método envia ao Hub IoT o resultado de um upload de blob.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Registra um retorno de chamada para um método chamado methodName.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)

O uploadToBlob método carrega um fluxo para um blob.

Métodos herdados

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

Escuta uma vez o abort evento no fornecido signal.

Ouvir o abort evento em sinais de anulação não é seguro e pode levar a vazamentos de recursos, já que outro terceiro com o sinal pode chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode alterar isso, pois violaria o padrão da Web. Além disso, a API original torna mais fácil esquecer de remover ouvintes.

Essa API permite usar AbortSignals com segurança em APIs Node.js resolvendo esses dois problemas ouvindo o evento de modo que stopImmediatePropagation não impeça a execução do ouvinte.

Retorna um descartável para que ele possa ser cancelado de mais facilmente.

import { addAbortListener } from 'node:events';

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

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

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.

Retornará 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 da mesma forma que chamar .listeners no emissor.

Para EventTargets, essa é a única maneira de obter os ouvintes de eventos para o destino do evento. Isso é útil para fins de depuração e diagnóstico.

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

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

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

Retorna a quantidade máxima de ouvintes definida no momento.

Para EventEmitters, isso se comporta exatamente da mesma forma que chamar .getMaxListeners no emissor.

Para EventTargets, essa é a única maneira de obter o máximo de ouvintes de eventos para o destino do evento. Se o número de manipuladores 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 determinado eventName registrado no determinado emitter.

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

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

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte for 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, StaticEventEmitterOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

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

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

Retorna um AsyncIterator que itera eventName eventos. Ele será lançado se o EventEmitter emitir 'error'. Ele remove todos os ouvintes ao sair do loop. O value retornado por cada iteração é uma matriz composta pelos argumentos de evento emitidos.

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

Adiciona a listener função 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 listener e chamada várias vezes.

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

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

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O emitter.prependListener() método 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, Pick<StaticEventEmitterOptions, "signal">)

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

Esse método é intencionalmente genérico e funciona com a interface EventTarget da plataforma Web, que não tem semântica de evento especial'error' e não escuta 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 aguardar outro evento. Se events.once() for usado para aguardar o evento 'error' em si, ele será 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

Um 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 únicalistener para o evento chamado eventName. Na próxima vez eventName que 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 , para EventEmitterque as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O emitter.prependOnceListener() método 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 listener função ao início 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 listener e chamada várias vezes.

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

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

Adiciona uma função únicalistener para o evento chamado eventName ao início da matriz de ouvintes. Na próxima vez eventName que 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 , para EventEmitterque 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 especificado eventName.

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

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

Remove o especificado listener 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 um único ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o especificado eventName, deverá removeListener() 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() chamada ou removeAllListeners()após a emissão e antes da conclusão da execução do último ouvinte não as removerá ememit() 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 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, conforme retornado pelo emitter.listeners() método, 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 once('ping') ouvinte é 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 , para EventEmitterque 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 do que 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O emitter.setMaxListeners() método permite que o limite seja modificado para essa instância específica EventEmitter . O valor pode ser definido Infinity como (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao , para EventEmitterque 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 do construtor

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface) 

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

Parâmetros

transport
DeviceTransport

Um objeto que implementa a interface esperada de um objeto de transporte, por exemplo, Http.

connStr

string

Uma cadeia de conexão (opcional: quando não fornecida, updateSharedAccessSignature deve ser chamada para definir o token SharedAccessSignature diretamente).

blobUploadClient

BlobUploadClient

Um objeto que é capaz de carregar um fluxo em um blob.

fileUploadApi

FileUploadInterface

Um objeto que é usado para se comunicar com o Hub IoT para ações relacionadas ao Armazenamento de Blobs.

Detalhes das propriedades herdadas

captureRejections

Valor: booliano

Altere 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 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 único. Esse limite pode ser alterado para instâncias individuais EventEmitter usando o emitter.setMaxListeners(n) método . Para alterar o padrão para todas asEventEmitter instâncias, a events.defaultMaxListeners propriedade pode ser usada. Se esse valor não for um número positivo, um RangeError será gerado.

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

Este não é um limite difícil. A EventEmitter instância permitirá que mais ouvintes sejam adicionados, mas gerará 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));
});

O --trace-warnings sinalizador de linha de comando pode ser usado para exibir o rastreamento de pilha para esses avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades , typee count adicionaisemitter, referindo-se à instância do emissor do evento, ao nome do evento e ao número de ouvintes anexados, 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 somente para eventos de monitoramento 'error' . Os ouvintes instalados usando esse símbolo são chamados antes que os ouvintes regulares 'error' sejam chamados.

Instalar um ouvinte usando esse símbolo não altera o comportamento depois que um 'error' evento é emitido. Portanto, o processo ainda falhará se nenhum ouvinte regular 'error' estiver 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 Client 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 dispositivo 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): Client

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

Client

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

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

Client

fromSharedAccessSignature(string, any)

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

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

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

Client

getBlobSharedAccessSignature(string) 

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

Parâmetros

blobName

string

Retornos

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

O getBlobSharedAccessSignature obtém o token SAS da conta de armazenamento vinculada do Hub IoT

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

Parâmetros

blobName

string

O nome a ser usado para o blob que será criado com o conteúdo do fluxo.

callback

Callback<UploadParams>

Retorno de chamada opcional para chamar quando o upload for concluído.

notifyBlobUploadStatus(string, boolean, number, string) 

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

Parâmetros

correlationId

string

isSuccess

boolean

statusCode

number

statusDescription

string

Retornos

Promise<void>

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

O notifyBlobUploadStatus método envia ao Hub IoT o resultado de um upload de blob.

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

Parâmetros

correlationId

string

Uma ID para correlacionar um status de upload a um blob específico. Gerado durante a chamada para getBlobSharedAccessSignature.

isSuccess

boolean

O status de êxito ou falha do resultado da operação de blob de armazenamento.

statusCode

number

O código de status HTTP associado ao resultado do blob de armazenamento.

statusDescription

string

A descrição do código de status HTTP.

callback

ErrorCallback

Retorno de chamada opcional para chamar quando o upload for concluído.

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

Registra um retorno de chamada para um método chamado methodName.

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

Parâmetros

methodName

string

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

callback

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

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

setOptions(DeviceClientOptions) 

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

Parâmetros

options
DeviceClientOptions

Retornos

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>) 

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

Parâmetros

options
DeviceClientOptions
done

Callback<TransportConfigured>

uploadToBlob(string, Stream, number) 

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

Parâmetros

blobName

string

stream

Stream

streamLength

number

Retornos

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

O uploadToBlob método carrega um fluxo para um blob.

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

Parâmetros

blobName

string

O nome a ser usado para o blob que será criado com o conteúdo do fluxo.

stream

Stream

Os dados para os quais devem ser carregados no blob.

streamLength

number

O tamanho dos dados para os quais devem ser carregados no blob.

callback

ErrorCallback

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)

Escuta uma vez o abort evento no fornecido signal.

Ouvir o abort evento em sinais de anulação não é seguro e pode levar a vazamentos de recursos, já que outro terceiro com o sinal pode chamar e.stopImmediatePropagation(). Infelizmente, Node.js não pode alterar isso, pois violaria o padrão da Web. Além disso, a API original torna mais fácil esquecer de remover ouvintes.

Essa API permite usar AbortSignals com segurança em APIs Node.js resolvendo esses dois problemas ouvindo o evento de modo que stopImmediatePropagation não impeça a execução do ouvinte.

Retorna um descartável para que ele possa ser cancelado de mais facilmente.

import { addAbortListener } from 'node:events';

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

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

Parâmetros

signal

AbortSignal

resource

(event: Event) => void

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Retornos

Client

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.

Retornará 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 da mesma forma que chamar .listeners no emissor.

Para EventTargets, essa é a única maneira de obter os ouvintes de eventos para o destino do evento. Isso é útil para fins de depuração e diagnóstico.

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

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

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | 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 qual é definido por emitter.setMaxListeners(n) ou o padrão é defaultMaxListeners.

function getMaxListeners(): number

Retornos

number

Herdado de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retorna a quantidade máxima de ouvintes definida no momento.

Para EventEmitters, isso se comporta exatamente da mesma forma que chamar .getMaxListeners no emissor.

Para EventTargets, essa é a única maneira de obter o máximo de ouvintes de eventos para o destino do evento. Se o número de manipuladores 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 determinado eventName registrado no determinado emitter.

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

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

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

Parâmetros

emitter

EventEmitter<DefaultEventMap>

O emissor a ser consultado

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Retornos

Client

Herdado de InternalClient.off

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

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

const ee = new EventEmitter();

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

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

Retorna um AsyncIterator que itera eventName eventos. Ele será lançado se o EventEmitter emitir 'error'. Ele remove todos os ouvintes ao sair do loop. O value retornado por cada iteração é uma matriz composta pelos argumentos de evento emitidos.

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

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

Parâmetros

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

O nome do evento que está sendo escutado

options

StaticEventEmitterOptions

Retornos

AsyncIterableIterator<any>

Um AsyncIterator que itera eventos emitidos eventName pelo emitter

Herdado de InternalClient.on

on(EventTarget, string, StaticEventEmitterOptions) 

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

Parâmetros

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Retornos

AsyncIterableIterator<any>

Herdado de InternalClient.on

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

Adiciona a listener função 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 listener e chamada várias vezes.

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

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

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O emitter.prependListener() método 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): Client

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de retorno de chamada

Retornos

Client

Herdado de InternalClient.on

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

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

Esse método é intencionalmente genérico e funciona com a interface EventTarget da plataforma Web, que não tem semântica de evento especial'error' e não escuta 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 aguardar outro evento. Se events.once() for usado para aguardar o evento 'error' em si, ele será 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

Um 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?: Pick<StaticEventEmitterOptions, "signal">): Promise<any[]>

Parâmetros

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

Pick<StaticEventEmitterOptions, "signal">

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 únicalistener para o evento chamado eventName. Na próxima vez eventName que 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 , para EventEmitterque as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O emitter.prependOnceListener() método 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): Client

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de retorno de chamada

Retornos

Client

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 listener função ao início 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 listener e chamada várias vezes.

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

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

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

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de retorno de chamada

Retornos

Client

Herdado de InternalClient.prependListener

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

Adiciona uma função únicalistener para o evento chamado eventName ao início da matriz de ouvintes. Na próxima vez eventName que 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 , para EventEmitterque as chamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

O nome do evento.

listener

(args: any[]) => void

A função de retorno de chamada

Retornos

Client

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 especificado eventName.

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

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

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

Parâmetros

eventName

string | symbol

Retornos

Client

Herdado de InternalClient.removeAllListeners

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

Remove o especificado listener 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 um único ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o especificado eventName, deverá removeListener() 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() chamada ou removeAllListeners()após a emissão e antes da conclusão da execução do último ouvinte não as removerá ememit() 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 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, conforme retornado pelo emitter.listeners() método, 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 once('ping') ouvinte é 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 , para EventEmitterque as chamadas possam ser encadeadas.

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Retornos

Client

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

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

function setMaxListeners(n: number): Client

Parâmetros

n

number

Retornos

Client

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

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