Client class
Hub IoT cliente de dispositivo utilizado para ligar um dispositivo a um hub IoT do Azure.
Os utilizadores do SDK devem chamar um dos métodos de fábrica, deConnectionString ou deSharedAccessSignature para criar um cliente de dispositivo Hub IoT.
- Extends
-
InternalClient
Construtores
Client(Device |
Propriedades Herdadas
capture |
Valor: booleano Altere a opção predefinida |
capture |
Valor: Veja como escrever um . |
default |
Por predefinição, um máximo de serviços de Tenha cuidado ao definir o Este não é um limite difícil. A
O O aviso emitido pode ser inspecionado com |
error |
Este símbolo deve ser utilizado para instalar um serviço de escuta apenas para eventos de monitorização Instalar um serviço de escuta com este símbolo não altera o comportamento depois de um |
Métodos
close() | |
close(Callback<Disconnected>) | Fecha a ligação de transporte e destrói os recursos do cliente. Nota: depois de chamar este método, o objeto Cliente não pode ser reutilizado. |
from |
Cria um cliente de dispositivo Hub IoT a partir do método de autenticação especificado e com o tipo de transporte especificado. |
from |
Cria um cliente de dispositivo Hub IoT a partir do cadeia de ligação especificado com o tipo de transporte especificado. |
from |
Cria um cliente de dispositivo Hub IoT a partir da assinatura de acesso partilhado fornecida com o tipo de transporte especificado. |
get |
|
get |
Obtém |
notify |
|
notify |
O |
on |
Regista uma chamada de retorno para um método chamado |
set |
|
set |
|
upload |
|
upload |
O |
Métodos Herdados
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Escuta uma vez o Ouvir o Esta API permite a utilização Devolve um descartável para que possa ser anulada a subscrição de mais facilmente.
|
add |
Alias para |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Chama de forma síncrona cada um dos serviços de escuta registados para o evento com o nome Devolve
|
event |
Devolve uma matriz que lista os eventos para os quais o emissor registou serviços de escuta. Os valores na matriz são cadeias ou
|
get |
Devolve uma cópia da matriz de serviços de escuta do evento com o nome Para Para
|
get |
Devolve o valor máximo do serviço de escuta atual para o |
get |
Devolve a quantidade máxima de serviços de escuta atualmente definida. Para Para
|
get |
|
get |
|
listener |
Um método de classe que devolve o número de serviços de escuta do dado
|
listener |
Devolve o número de serviços de escuta que escutam o evento com o nome |
listeners<K>(string | symbol) | Devolve uma cópia da matriz de serviços de escuta do evento com o nome
|
off<K>(string | symbol, (args: any[]) => void) | Alias para |
on(Event |
Devolve um Um
|
on<K>(string | symbol, (args: any[]) => void) | Adiciona a
Devolve uma referência ao , para que as Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O
|
once(Event |
Cria um Este método é intencionalmente genérico e funciona com a interface EventTarget da plataforma Web, que não tem semântica de evento especial
O processamento especial do
Um
|
once(_DOMEvent |
|
once<K>(string | symbol, (args: any[]) => void) | Adiciona uma função única
Devolve uma referência ao , para que as Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O
|
open() | |
open(Callback<Connected>) | |
prepend |
Adiciona a
Devolve uma referência ao , para que as |
prepend |
Adiciona uma função única
Devolve uma referência ao , para que as |
raw |
Devolve uma cópia da matriz de serviços de escuta do evento com o nome
|
reject(Message) | |
reject(Message, Callback<Message |
|
remove |
Remove todos os serviços de escuta ou os dos especificados É uma má prática remover os serviços de escuta adicionados noutros locais do código, especialmente quando a Devolve uma referência ao , para que as |
remove |
Remove o especificado
Assim que um evento for emitido, todos os serviços de escuta anexados ao mesmo no momento da emissão são chamados por ordem. Isto implica que qualquer
Uma vez que os serviços de escuta são geridos através de uma matriz interna, chamar isto irá alterar os índices de posição de qualquer serviço de escuta registado após a remoção do serviço de escuta. Isto não afetará a ordem pela qual os serviços de escuta são chamados, mas significa que todas as cópias da matriz do serviço de escuta, conforme devolvido pelo Quando uma única função tiver sido adicionada como processador várias vezes para um único evento (como no exemplo abaixo),
Devolve uma referência ao , para que as |
send |
|
send |
|
send |
|
send |
|
set |
Por predefinição Devolve uma referência ao , para que as |
set |
|
set |
Define a política de repetição utilizada pelo cliente em todas as operações. A predefinição é ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
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 ligação (opcional: quando não for fornecida, updateSharedAccessSignature tem de ser chamada para definir o token SharedAccessSignature diretamente).
- blobUploadClient
-
BlobUploadClient
Um objeto capaz de carregar um fluxo para um blob.
- fileUploadApi
-
FileUploadInterface
Um objeto que é utilizado para comunicar com Hub IoT para ações relacionadas com o Armazenamento de Blobs.
Detalhes da Propriedade Herdada
captureRejections
Valor: booleano
Altere a opção predefinida captureRejections
em todos os novos EventEmitter
objetos.
static captureRejections: boolean
Valor de Propriedade
boolean
Herdado de InternalClient.captureRejections
captureRejectionSymbol
Valor: Symbol.for('nodejs.rejection')
Veja como escrever um .rejection handler
static captureRejectionSymbol: typeof captureRejectionSymbol
Valor de Propriedade
typeof captureRejectionSymbol
Herdado de InternalClient.captureRejectionSymbol
defaultMaxListeners
Por predefinição, um máximo de serviços de 10
escuta pode ser registado em qualquer evento individual. Este limite pode ser alterado para instâncias individuais EventEmitter
com o emitter.setMaxListeners(n)
método . Para alterar a predefinição para todas asEventEmitter
instâncias, a events.defaultMaxListeners
propriedade pode ser utilizada. Se este valor não for um número positivo, é emitido um RangeError
.
Tenha cuidado ao definir o events.defaultMaxListeners
porque a alteração afeta todas asEventEmitter
instâncias, incluindo as criadas antes de a alteração ser efetuada. No entanto, as chamadas emitter.setMaxListeners(n)
ainda têm precedência sobre events.defaultMaxListeners
.
Este não é um limite difícil. A EventEmitter
instância permitirá a adição de mais serviços de escuta, mas irá enviar um aviso de rastreio para stderr que indica que foi detetada uma "possível fuga de memória eventEmitter". Para qualquer , EventEmitter
os emitter.getMaxListeners()
métodos e emitter.setMaxListeners()
podem ser utilizados para evitar temporariamente este aviso:
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
// do stuff
emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});
O --trace-warnings
sinalizador da linha de comandos pode ser utilizado para apresentar o rastreio da pilha para tais avisos.
O aviso emitido pode ser inspecionado com process.on('warning')
e terá as propriedades adicionais emitter
, type
e count
, referindo-se à instância do emissor de eventos, ao nome do evento e ao número de serviços de escuta anexados, respetivamente.
A name
propriedade está definida como 'MaxListenersExceededWarning'
.
static defaultMaxListeners: number
Valor de Propriedade
number
Herdado de InternalClient.defaultMaxListeners
errorMonitor
Este símbolo deve ser utilizado para instalar um serviço de escuta apenas para eventos de monitorização 'error'
. Os serviços de escuta instalados com este símbolo são chamados antes de os serviços de escuta regulares 'error'
serem chamados.
Instalar um serviço de escuta com este símbolo não altera o comportamento depois de um 'error'
evento ser emitido. Por conseguinte, o processo continuará a falhar se não estiver instalado nenhum serviço de escuta normal 'error'
.
static errorMonitor: typeof errorMonitor
Valor de Propriedade
typeof errorMonitor
Herdado de InternalClient.errorMonitor
Detalhes de Método
close()
function close(): Promise<Disconnected>
Devoluções
Promise<Disconnected>
close(Callback<Disconnected>)
Fecha a ligação de transporte e destrói os recursos do cliente.
Nota: depois de chamar este método, o objeto Cliente não pode ser reutilizado.
function close(closeCallback?: Callback<Disconnected>)
Parâmetros
- closeCallback
-
Callback<Disconnected>
Função opcional para chamar assim que o transporte estiver desligado e o cliente fechado.
fromAuthenticationProvider(AuthenticationProvider, any)
Cria um cliente de dispositivo Hub IoT a partir do método de autenticação especificado e com o tipo de transporte especificado.
static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client
Parâmetros
- authenticationProvider
-
AuthenticationProvider
Objeto utilizado para obter os parâmetros de autenticação do hub IoT.
- transportCtor
-
any
Protocolo de transporte utilizado para ligar ao hub IoT.
Devoluções
fromConnectionString(string, any)
Cria um cliente de dispositivo Hub IoT a partir do cadeia de ligação especificado com o tipo de transporte especificado.
static function fromConnectionString(connStr: string, transportCtor: any): Client
Parâmetros
- connStr
-
string
Uma cadeia de ligação que encapsula as permissões de "ligação do dispositivo" num hub IoT.
- transportCtor
-
any
Um construtor de transportes.
Devoluções
fromSharedAccessSignature(string, any)
Cria um cliente de dispositivo Hub IoT a partir da assinatura de acesso partilhado fornecida com o tipo de transporte especificado.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client
Parâmetros
- sharedAccessSignature
-
string
Uma assinatura de acesso partilhado que encapsula permissões de "ligação do dispositivo" num hub IoT.
- transportCtor
-
any
Devoluções
getBlobSharedAccessSignature(string)
function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>
Parâmetros
- blobName
-
string
Devoluções
Promise<UploadParams>
getBlobSharedAccessSignature(string, Callback<UploadParams>)
Obtém getBlobSharedAccessSignature
o Token de SAS da conta de armazenamento ligada a partir de Hub IoT
function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)
Parâmetros
- blobName
-
string
O nome a utilizar para o blob que será criado com o conteúdo do fluxo.
- callback
-
Callback<UploadParams>
Chamada de retorno opcional para ligar quando o carregamento estiver 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
Devoluções
Promise<void>
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)
O notifyBlobUploadStatus
método envia Hub IoT o resultado de um carregamento de blobs.
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)
Parâmetros
- correlationId
-
string
Um ID para correlacionar um estado de carregamento com um blob específico. Gerado durante a chamada para getBlobSharedAccessSignature
.
- isSuccess
-
boolean
O estado de êxito ou falha do resultado da operação de blobs de armazenamento.
- statusCode
-
number
O código de estado HTTP associado ao resultado do blob de armazenamento.
- statusDescription
-
string
A descrição do código de estado HTTP.
- callback
-
ErrorCallback
Chamada de retorno opcional para ligar quando o carregamento estiver concluído.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Regista uma chamada de retorno 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á processado pela chamada de retorno
- callback
-
(request: DeviceMethodRequest, response: DeviceMethodResponse) => void
Função que deve ser chamada sempre que for recebido um pedido de método para o método denominado methodName
.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Parâmetros
- options
- DeviceClientOptions
Devoluções
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
Devoluções
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 utilizar para o blob que será criado com o conteúdo do fluxo.
- stream
-
Stream
Os dados devem ser carregados para o blob.
- streamLength
-
number
O tamanho dos dados para os quais devem ser carregados para o blob.
- callback
-
ErrorCallback
Detalhes do Método Herdado
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Parâmetros
- message
- Message
Devoluções
Promise<MessageAbandoned>
Herdado de InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Parâmetros
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
Herdado de InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Escuta uma vez o abort
evento no fornecido signal
.
Ouvir o abort
evento em sinais de abortar não é seguro e pode levar a fugas de recursos, uma vez que outros terceiros com o sinal podem chamar e.stopImmediatePropagation()
. Infelizmente, Node.js não pode alterar esta situação, uma vez que violaria a norma Web. Além disso, a API original facilita a remoção de serviços de escuta.
Esta API permite a utilização AbortSignal
segura de s nas APIs Node.js ao resolver estes dois problemas ao escutar o evento de forma a stopImmediatePropagation
não impedir a execução do serviço de escuta.
Devolve um descartável para que possa ser anulada a subscrição de mais facilmente.
import { addAbortListener } from 'node:events';
function example(signal) {
let disposable;
try {
signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
disposable = addAbortListener(signal, (e) => {
// Do something when signal is aborted.
});
} finally {
disposable?.[Symbol.dispose]();
}
}
static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable
Parâmetros
- signal
-
AbortSignal
- resource
-
(event: Event) => void
Devoluções
Disposable
Descartável que remove o abort
serviço de escuta.
Herdado de InternalClient.addAbortListener
addListener<K>(string | symbol, (args: any[]) => void)
Alias para emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parâmetros
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Devoluções
Herdado de InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Parâmetros
- message
- Message
Devoluções
Promise<MessageCompleted>
Herdado de InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Parâmetros
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
Herdado de InternalClient.complete
emit<K>(string | symbol, AnyRest)
Chama de forma síncrona cada um dos serviços de escuta registados para o evento com o nome eventName
, pela ordem em que foram registados, transmitindo os argumentos fornecidos para cada um.
Devolve true
se o evento tiver serviços de escuta, false
caso contrário.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
function emit<K>(eventName: string | symbol, args: AnyRest): boolean
Parâmetros
- eventName
-
string | symbol
- args
-
AnyRest
Devoluções
boolean
Herdado de InternalClient.emit
eventNames()
Devolve uma matriz que lista os eventos para os quais o emissor registou serviços de escuta. Os valores na matriz são cadeias ou Symbol
s.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
function eventNames(): (string | symbol)[]
Devoluções
(string | symbol)[]
Herdado de InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget, string | symbol)
Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName
.
Para EventEmitter
s, este comportamento tem exatamente o mesmo comportamento que chamar .listeners
o emissor.
Para EventTarget
s, esta é a única forma de obter os serviços de escuta de eventos para o destino do evento. Isto é útil para fins de depuração e diagnóstico.
import { getEventListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | _DOMEventTarget, name: string | symbol): Function[]
Parâmetros
- emitter
-
EventEmitter<DefaultEventMap> | _DOMEventTarget
- name
-
string | symbol
Devoluções
Function[]
Herdado de InternalClient.getEventListeners
getMaxListeners()
Devolve o valor máximo do serviço de escuta atual para o EventEmitter
que está definido por emitter.setMaxListeners(n)
ou predefinição para defaultMaxListeners.
function getMaxListeners(): number
Devoluções
number
Herdado de InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)
Devolve a quantidade máxima de serviços de escuta atualmente definida.
Para EventEmitter
s, este comportamento tem exatamente o mesmo comportamento que chamar .getMaxListeners
o emissor.
Para EventTarget
s, esta é a única forma de obter o número máximo de serviços de escuta de eventos para o destino do evento. Se o número de processadores de eventos num único EventTarget exceder o conjunto máximo, o EventTarget irá imprimir um aviso.
import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
{
const ee = new EventEmitter();
console.log(getMaxListeners(ee)); // 10
setMaxListeners(11, ee);
console.log(getMaxListeners(ee)); // 11
}
{
const et = new EventTarget();
console.log(getMaxListeners(et)); // 10
setMaxListeners(11, et);
console.log(getMaxListeners(et)); // 11
}
static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | _DOMEventTarget): number
Parâmetros
- emitter
-
EventEmitter<DefaultEventMap> | _DOMEventTarget
Devoluções
number
Herdado de InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Parâmetros
- done
-
Callback<Twin>
Herdado de InternalClient.getTwin
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Aviso
Esta API foi preterida.
Since v3.2.0 - Use listenerCount
instead.
Um método de classe que devolve o número de serviços de escuta do dado eventName
registado no especificado emitter
.
import { EventEmitter, listenerCount } from 'node:events';
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number
Parâmetros
- emitter
-
EventEmitter<DefaultEventMap>
O emissor a consultar
- eventName
-
string | symbol
O nome do evento
Devoluções
number
Herdado de InternalClient.listenerCount
listenerCount<K>(string | symbol, Function)
Devolve o número de serviços de escuta que escutam o evento com o nome eventName
.
Se listener
for fornecido, devolverá o número de vezes que o serviço de escuta é encontrado na lista de serviços de escuta do evento.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Parâmetros
- eventName
-
string | symbol
O nome do evento que está a ser escutado
- listener
-
Function
A função do processador de eventos
Devoluções
number
Herdado de InternalClient.listenerCount
listeners<K>(string | symbol)
Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName
.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
function listeners<K>(eventName: string | symbol): Function[]
Parâmetros
- eventName
-
string | symbol
Devoluções
Function[]
Herdado de InternalClient.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias para emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parâmetros
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Devoluções
Herdado de InternalClient.off
on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions)
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
Devolve um AsyncIterator
que itera eventos eventName
. Será emitida se o EventEmitter
emiter 'error'
. Remove todos os serviços de escuta ao sair do ciclo. O value
devolvido por cada iteração é uma matriz composta pelos argumentos de evento emitidos.
Um AbortSignal
pode ser utilizado para cancelar a espera de eventos:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>
Parâmetros
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string
O nome do evento que está a ser escutado
- options
-
StaticEventEmitterOptions
Devoluções
AsyncIterableIterator<any>
Um AsyncIterator
que itera eventos emitidos eventName
pelo emitter
Herdado de InternalClient.on
on<K>(string | symbol, (args: any[]) => void)
Adiciona a listener
função ao fim da matriz de serviços de escuta do evento com o nome eventName
. Não são efetuadas verificações para ver se o listener
já foi adicionado. Múltiplas chamadas que transmitem a mesma combinação de eventName
e listener
resultarão na adição listener
e chamada de várias vezes.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Devolve uma referência ao , para que as EventEmitter
chamadas possam ser encadeadas.
Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependListener()
método pode ser utilizado como alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
function on<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parâmetros
- eventName
-
string | symbol
O nome do evento.
- listener
-
(args: any[]) => void
A função de chamada de retorno
Devoluções
Herdado de InternalClient.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
Cria um Promise
que é cumprido quando emite o EventEmitter
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 especificado.
Este 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 ouve o 'error'
evento.
import { once, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.error('error happened', err);
}
O processamento especial do 'error'
evento só é utilizado quando events.once()
é utilizado para aguardar por outro evento. Se events.once()
for utilizado para aguardar o evento emerror'
si, será tratado como qualquer outro tipo de evento sem processamento especial:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.error('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
Um AbortSignal
pode ser utilizado para cancelar a espera do evento:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>
Parâmetros
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
Devoluções
Promise<any[]>
Herdado de InternalClient.once
once(_DOMEventTarget, string, StaticEventEmitterOptions)
static function once(emitter: _DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Parâmetros
- emitter
-
_DOMEventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Devoluções
Promise<any[]>
Herdado de InternalClient.once
once<K>(string | symbol, (args: any[]) => void)
Adiciona uma função únicalistener
para o evento com o nome eventName
. Da próxima vez eventName
que for acionado, este serviço de escuta é removido e, em seguida, invocado.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Devolve uma referência ao , para que as EventEmitter
chamadas possam ser encadeadas.
Por predefinição, os serviços de escuta de eventos são invocados pela ordem em que são adicionados. O emitter.prependOnceListener()
método pode ser utilizado como alternativa para adicionar o serviço de escuta de eventos ao início da matriz de serviços de escuta.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
function once<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parâmetros
- eventName
-
string | symbol
O nome do evento.
- listener
-
(args: any[]) => void
A função de chamada de retorno
Devoluções
Herdado de InternalClient.once
open()
function open(): Promise<Connected>
Devoluções
Promise<Connected>
Herdado de InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Parâmetros
- openCallback
-
Callback<Connected>
Herdado de InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Adiciona a listener
função ao início da matriz de serviços de escuta do evento com o nome eventName
. Não são efetuadas verificações para ver se o listener
já foi adicionado. Múltiplas chamadas que transmitem a mesma combinação de eventName
e listener
resultarão na adição listener
e chamada de várias vezes.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Devolve uma referência ao , para que as EventEmitter
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 chamada de retorno
Devoluções
Herdado de InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Adiciona uma função únicalistener
para o evento com o nome eventName
ao início da matriz de serviços de escuta. Da próxima vez eventName
que for acionado, este serviço de escuta é removido e, em seguida, invocado.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Devolve uma referência ao , para que as EventEmitter
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 chamada de retorno
Devoluções
Herdado de InternalClient.prependOnceListener
rawListeners<K>(string | symbol)
Devolve uma cópia da matriz de serviços de escuta do evento com o nome eventName
, incluindo quaisquer wrappers (como os criados por .once()
).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
function rawListeners<K>(eventName: string | symbol): Function[]
Parâmetros
- eventName
-
string | symbol
Devoluções
Function[]
Herdado de InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Parâmetros
- message
- Message
Devoluções
Promise<MessageRejected>
Herdado de InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Parâmetros
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
Herdado de InternalClient.reject
removeAllListeners(string | symbol)
Remove todos os serviços de escuta ou os dos especificados eventName
.
É uma má prática remover os serviços de escuta adicionados noutros locais do código, especialmente quando a EventEmitter
instância foi criada por outro componente ou módulo (por exemplo, sockets ou fluxos de ficheiros).
Devolve uma referência ao , para que as EventEmitter
chamadas possam ser encadeadas.
function removeAllListeners(eventName?: string | symbol): Client
Parâmetros
- eventName
-
string | symbol
Devoluções
Herdado de InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Remove o especificado listener
da matriz do serviço de escuta do evento com o nome eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
irá remover, no máximo, uma instância de um serviço de escuta da matriz do serviço de escuta. Se um único serviço de escuta tiver sido adicionado várias vezes à matriz do serviço de escuta para o especificado eventName
, tem de removeListener()
ser chamado várias vezes para remover cada instância.
Assim que um evento for emitido, todos os serviços de escuta anexados ao mesmo no momento da emissão são chamados por ordem. Isto implica que qualquer removeListener()
ou removeAllListeners()
chamadas após emitir e antes da última execução do serviço de escuta não as removerá ememit()
curso. Os eventos subsequentes comportam-se conforme esperado.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
Uma vez que os serviços de escuta são geridos através de uma matriz interna, chamar isto irá alterar os índices de posição de qualquer serviço de escuta registado após a remoção do serviço de escuta. Isto não afetará a ordem pela qual os serviços de escuta são chamados, mas significa que todas as cópias da matriz do serviço de escuta, conforme devolvido pelo emitter.listeners()
método, terão de ser recriadas.
Quando uma única função tiver sido adicionada como processador várias vezes para um único evento (como no exemplo abaixo), removeListener()
removerá a instância adicionada mais recentemente. No exemplo, o once('ping')
serviço de escuta é removido:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
Devolve uma referência ao , para que as EventEmitter
chamadas possam ser encadeadas.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parâmetros
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Devoluções
Herdado de InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Parâmetros
- message
- Message
Devoluções
Promise<MessageEnqueued>
Herdado de InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Parâmetros
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
Herdado de InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Parâmetros
- messages
-
Message[]
Devoluções
Promise<MessageEnqueued>
Herdado de InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Parâmetros
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
Herdado de InternalClient.sendEventBatch
setMaxListeners(number)
Por predefinição EventEmitter
, s irá imprimir um aviso se mais do que 10
os serviços de escuta forem adicionados para um evento específico. Esta é uma predefinição útil que ajuda a encontrar fugas de memória. O emitter.setMaxListeners()
método permite que o limite seja modificado para esta instância específica EventEmitter
. O valor pode ser definido como Infinity
(ou 0
) para indicar um número ilimitado de serviços de escuta.
Devolve uma referência ao , para que as EventEmitter
chamadas possam ser encadeadas.
function setMaxListeners(n: number): Client
Parâmetros
- n
-
number
Devoluções
Herdado de InternalClient.setMaxListeners
setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[])
import { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | _DOMEventTarget)[])
Parâmetros
- n
-
number
Um número não negativo. O número máximo de serviços de escuta por EventTarget
evento.
- eventTargets
-
(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]
Herdado de InternalClient.setMaxListeners
setRetryPolicy(RetryPolicy)
Define a política de repetição utilizada pelo cliente em todas as operações. A predefinição é ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Parâmetros
- policy
-
RetryPolicy
{RetryPolicy} A política de repetição que deve ser utilizada para todas as operações futuras.
Herdado de InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Parâmetros
- options
-
any
Devoluções
Promise<TransportConfigured>
Herdado de InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Parâmetros
- options
-
any
- done
-
Callback<TransportConfigured>
Herdado de InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Parâmetros
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
Herdado de InternalClient.updateSharedAccessSignature
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Parâmetros
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
Herdado de InternalClient.__@captureRejectionSymbol@138