Client class
IoT Hub cliente de dispositivo usado para conectar un dispositivo con una instancia de Azure IoT Hub.
Los usuarios del SDK deben llamar a uno de los métodos de fábrica, fromConnectionString o fromSharedAccessSignature para crear un cliente de dispositivo IoT Hub.
- Extends
-
InternalClient
Constructores
Client(Device |
Propiedades heredadas
capture |
Valor: booleano Cambie la opción predeterminada |
capture |
Valor: Vea cómo escribir un personalizado |
default |
De forma predeterminada, se puede registrar un máximo de agentes de Tenga cuidado al establecer Esto no es un límite estricto. La
La La advertencia emitida se puede inspeccionar con |
error |
Este símbolo se usará para instalar un agente de escucha solo para supervisar La instalación de un agente de escucha mediante este símbolo no cambia el comportamiento una vez emitido un |
Métodos
close() | |
close(Callback<Disconnected>) | Cierra la conexión de transporte y destruye los recursos del cliente. Nota: Después de llamar a este método, no se puede reutilizar el objeto Client. |
from |
Crea un cliente de dispositivo IoT Hub a partir del método de autenticación especificado y usa el tipo de transporte especificado. |
from |
Crea un cliente de dispositivo IoT Hub a partir del cadena de conexión especificado mediante el tipo de transporte especificado. |
from |
Crea un cliente de dispositivo IoT Hub a partir de la firma de acceso compartido dada mediante el tipo de transporte especificado. |
get |
|
get |
|
notify |
|
notify |
El |
on |
Registra una devolución de llamada para un método denominado |
set |
|
set |
|
upload |
|
upload |
El |
Métodos heredados
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Escucha una vez al Escuchar el Esta API permite usar Devuelve un descartable para que se pueda cancelar la suscripción más fácilmente.
|
add |
Alias para |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado Devuelve
|
event |
Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha. Los valores de la matriz son cadenas o
|
get |
Devuelve una copia de la matriz de agentes de escucha para el evento denominado Para Para
|
get |
Devuelve el valor del agente de escucha máximo actual para el |
get |
Devuelve la cantidad máxima establecida actualmente de agentes de escucha. Para Para
|
get |
|
get |
|
listener |
Método de clase que devuelve el número de agentes de escucha para el especificado
|
listener |
Devuelve el número de agentes de escucha que escuchan el evento denominado |
listeners<K>(string | symbol) | Devuelve una copia de la matriz de agentes de escucha para el evento denominado
|
off<K>(string | symbol, (args: any[]) => void) | Alias para |
on(Event |
Devuelve un
|
on<K>(string | symbol, (args: any[]) => void) | Agrega la
Devuelve una referencia a De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El
|
once(Event |
Crea un Este método es genérico intencionadamente y funciona con la interfaz EventTarget de la plataforma web, que no tiene semántica de eventos especiales
El control especial del
Se
|
once(_DOMEvent |
|
once<K>(string | symbol, (args: any[]) => void) | Agrega una función única
Devuelve una referencia a De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El
|
open() | |
open(Callback<Connected>) | |
prepend |
Agrega la
Devuelve una referencia a |
prepend |
Agrega una función única
Devuelve una referencia a |
raw |
Devuelve una copia de la matriz de agentes de escucha para el evento denominado
|
reject(Message) | |
reject(Message, Callback<Message |
|
remove |
Quita todos los agentes de escucha o los del especificado No es recomendable quitar los agentes de escucha agregados en otro lugar del código, especialmente cuando la Devuelve una referencia a |
remove |
Quita el especificado
Una vez emitido un evento, todos los agentes de escucha adjuntos a él en el momento de emitir se llaman en orden. Esto implica que cualquier
Dado que los agentes de escucha se administran mediante una matriz interna, llamar a esto cambiará los índices de posición de cualquier agente de escucha registrado después de quitar el agente de escucha. Esto no afectará al orden en el que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el Cuando se haya agregado una sola función como controlador varias veces para un único evento (como en el ejemplo siguiente),
Devuelve una referencia a |
send |
|
send |
|
send |
|
send |
|
set |
De forma predeterminada Devuelve una referencia a |
set |
|
set |
Establece la directiva de reintento usada por el cliente en todas las operaciones. El valor predeterminado es ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
Detalles del constructor
Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)
new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)
Parámetros
- transport
- DeviceTransport
Objeto que implementa la interfaz esperada de un objeto de transporte, por ejemplo, Http.
- connStr
-
string
Un cadena de conexión (opcional: cuando no se proporciona, se debe llamar a updateSharedAccessSignature para establecer el token de SharedAccessSignature directamente).
- blobUploadClient
-
BlobUploadClient
Objeto que es capaz de cargar una secuencia en un blob.
- fileUploadApi
-
FileUploadInterface
Objeto que se usa para comunicarse con IoT Hub para acciones relacionadas con Blob Storage.
Detalles de las propiedades heredadas
captureRejections
Valor: booleano
Cambie la opción predeterminada captureRejections
en todos los objetos nuevos EventEmitter
.
static captureRejections: boolean
Valor de propiedad
boolean
Heredado de InternalClient.captureRejections
captureRejectionSymbol
Valor: Symbol.for('nodejs.rejection')
Vea cómo escribir un personalizado rejection handler
.
static captureRejectionSymbol: typeof captureRejectionSymbol
Valor de propiedad
typeof captureRejectionSymbol
Heredado de InternalClient.captureRejectionSymbol
defaultMaxListeners
De forma predeterminada, se puede registrar un máximo de agentes de 10
escucha para cualquier evento único. Este límite se puede cambiar para instancias individuales EventEmitter
mediante el emitter.setMaxListeners(n)
método . Para cambiar el valor predeterminado de todas lasEventEmitter
instancias, se puede usar la events.defaultMaxListeners
propiedad . Si este valor no es un número positivo, se produce una RangeError
excepción .
Tenga cuidado al establecer events.defaultMaxListeners
porque el cambio afecta a todas lasEventEmitter
instancias, incluidas las creadas antes de realizar el cambio. Sin embargo, la llamada emitter.setMaxListeners(n)
a todavía tiene prioridad sobre events.defaultMaxListeners
.
Esto no es un límite estricto. La EventEmitter
instancia permitirá agregar más agentes de escucha, pero generará una advertencia de seguimiento en stderr que indica que se ha detectado una "posible fuga de memoria eventEmitter". Para cualquier método único EventEmitter
, los emitter.getMaxListeners()
métodos y emitter.setMaxListeners()
se pueden usar para evitar temporalmente esta advertencia:
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));
});
La --trace-warnings
marca de línea de comandos se puede usar para mostrar el seguimiento de la pila para estas advertencias.
La advertencia emitida se puede inspeccionar con process.on('warning')
y tendrá las emitter
propiedades adicionales , type
y count
, que hacen referencia a la instancia del emisor de eventos, el nombre del evento y el número de agentes de escucha adjuntos, respectivamente.
Su name
propiedad se establece en 'MaxListenersExceededWarning'
.
static defaultMaxListeners: number
Valor de propiedad
number
Heredado de InternalClient.defaultMaxListeners
errorMonitor
Este símbolo se usará para instalar un agente de escucha solo para supervisar 'error'
eventos. Se llama a los agentes de escucha instalados mediante este símbolo antes de llamar a los agentes de escucha normales 'error'
.
La instalación de un agente de escucha mediante este símbolo no cambia el comportamiento una vez emitido un 'error'
evento. Por lo tanto, el proceso se bloqueará si no hay ningún agente de escucha normal 'error'
instalado.
static errorMonitor: typeof errorMonitor
Valor de propiedad
typeof errorMonitor
Heredado de InternalClient.errorMonitor
Detalles del método
close()
function close(): Promise<Disconnected>
Devoluciones
Promise<Disconnected>
close(Callback<Disconnected>)
Cierra la conexión de transporte y destruye los recursos del cliente.
Nota: Después de llamar a este método, no se puede reutilizar el objeto Client.
function close(closeCallback?: Callback<Disconnected>)
Parámetros
- closeCallback
-
Callback<Disconnected>
Función opcional a la que se llamará una vez que se desconecte el transporte y se cierre el cliente.
fromAuthenticationProvider(AuthenticationProvider, any)
Crea un cliente de dispositivo IoT Hub a partir del método de autenticación especificado y usa el tipo de transporte especificado.
static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client
Parámetros
- authenticationProvider
-
AuthenticationProvider
Objeto que se usa para obtener los parámetros de autenticación del centro de IoT.
- transportCtor
-
any
Protocolo de transporte que se usa para conectarse a IoT Hub.
Devoluciones
fromConnectionString(string, any)
Crea un cliente de dispositivo IoT Hub a partir del cadena de conexión especificado mediante el tipo de transporte especificado.
static function fromConnectionString(connStr: string, transportCtor: any): Client
Parámetros
- connStr
-
string
Un cadena de conexión que encapsula los permisos de "conexión de dispositivos" en un centro de IoT.
- transportCtor
-
any
Constructor de transporte.
Devoluciones
fromSharedAccessSignature(string, any)
Crea un cliente de dispositivo IoT Hub a partir de la firma de acceso compartido dada mediante el tipo de transporte especificado.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client
Parámetros
- sharedAccessSignature
-
string
Una firma de acceso compartido que encapsula los permisos de "conexión de dispositivos" en un centro de IoT.
- transportCtor
-
any
Devoluciones
getBlobSharedAccessSignature(string)
function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>
Parámetros
- blobName
-
string
Devoluciones
Promise<UploadParams>
getBlobSharedAccessSignature(string, Callback<UploadParams>)
getBlobSharedAccessSignature
obtiene el token de SAS de la cuenta de almacenamiento vinculada de IoT Hub
function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)
Parámetros
- blobName
-
string
Nombre que se va a usar para el blob que se creará con el contenido de la secuencia.
- callback
-
Callback<UploadParams>
Devolución de llamada opcional para llamar cuando se complete la carga.
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
Devoluciones
Promise<void>
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)
El notifyBlobUploadStatus
método envía IoT Hub el resultado de una carga de blobs.
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)
Parámetros
- correlationId
-
string
Identificador para correlacionar un estado de carga a un blob específico. Generado durante la llamada a getBlobSharedAccessSignature
.
- isSuccess
-
boolean
Estado correcto o de error del resultado de la operación de blob de almacenamiento.
- statusCode
-
number
Código de estado HTTP asociado al resultado del blob de almacenamiento.
- statusDescription
-
string
Descripción del código de estado HTTP.
- callback
-
ErrorCallback
Devolución de llamada opcional para llamar cuando se complete la carga.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Registra una devolución de llamada para un método denominado methodName
.
function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Parámetros
- methodName
-
string
Nombre del método que controlará la devolución de llamada
- callback
-
(request: DeviceMethodRequest, response: DeviceMethodResponse) => void
Función a la que se llamará cada vez que se recibe una solicitud de método para el método al que se llama methodName
.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Parámetros
- options
- DeviceClientOptions
Devoluciones
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
Devoluciones
Promise<void>
uploadToBlob(string, Stream, number, ErrorCallback)
El uploadToBlob
método carga una secuencia en un blob.
function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)
Parámetros
- blobName
-
string
Nombre que se va a usar para el blob que se creará con el contenido de la secuencia.
- stream
-
Stream
Los datos a los que se debe cargar en el blob.
- streamLength
-
number
Tamaño de los datos a los que se debe cargar en el blob.
- callback
-
ErrorCallback
Detalles de los métodos heredados
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Parámetros
- message
- Message
Devoluciones
Promise<MessageAbandoned>
Heredado de InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Parámetros
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
Heredado de InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Escucha una vez al abort
evento en el proporcionado signal
.
Escuchar el abort
evento en señales de anulación no es seguro y puede provocar pérdidas de recursos, ya que otro tercero con la señal puede llamar a e.stopImmediatePropagation()
. Desafortunadamente, Node.js no puede cambiar esto, ya que infringiría el estándar web. Además, la API original facilita la eliminación de agentes de escucha.
Esta API permite usar AbortSignal
de forma segura s en Node.js API mediante la resolución de estos dos problemas mediante la escucha del evento, de modo que no impide que stopImmediatePropagation
el agente de escucha se ejecute.
Devuelve un descartable para que se pueda cancelar la suscripción más fácilmente.
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
Devoluciones
Disposable
Descartable que quita el agente de abort
escucha.
Heredado 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
Devoluciones
Heredado de InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Parámetros
- message
- Message
Devoluciones
Promise<MessageCompleted>
Heredado de InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Parámetros
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
Heredado de InternalClient.complete
emit<K>(string | symbol, AnyRest)
Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado eventName
, en el orden en que se registraron, pasando los argumentos proporcionados a cada uno.
Devuelve true
si el evento tenía agentes de escucha; de lo contrario, false
devuelve .
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
Devoluciones
boolean
Heredado de InternalClient.emit
eventNames()
Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha. Los valores de la matriz son cadenas o 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)[]
Devoluciones
(string | symbol)[]
Heredado de InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget, string | symbol)
Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName
.
Para EventEmitter
s esto se comporta exactamente igual que llamar .listeners
a en el emisor.
Para EventTarget
s, esta es la única manera de obtener los agentes de escucha de eventos para el destino del evento. Esto es útil para fines de depuración y 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
Devoluciones
Function[]
Heredado de InternalClient.getEventListeners
getMaxListeners()
Devuelve el valor del agente de escucha máximo actual para el EventEmitter
que se establece de emitter.setMaxListeners(n)
forma predeterminada en defaultMaxListeners.
function getMaxListeners(): number
Devoluciones
number
Heredado de InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)
Devuelve la cantidad máxima establecida actualmente de agentes de escucha.
Para EventEmitter
s esto se comporta exactamente igual que llamar .getMaxListeners
a en el emisor.
Para EventTarget
s, esta es la única manera de obtener el número máximo de agentes de escucha de eventos para el destino del evento. Si el número de controladores de eventos en un único EventTarget supera el conjunto máximo, EventTarget imprimirá una advertencia.
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
Devoluciones
number
Heredado de InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Parámetros
- done
-
Callback<Twin>
Heredado de InternalClient.getTwin
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Advertencia
Esta API ya está en desuso.
Since v3.2.0 - Use listenerCount
instead.
Método de clase que devuelve el número de agentes de escucha para el especificado eventName
registrado en el 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>
Emisor al que se va a consultar
- eventName
-
string | symbol
Nombre del evento
Devoluciones
number
Heredado de InternalClient.listenerCount
listenerCount<K>(string | symbol, Function)
Devuelve el número de agentes de escucha que escuchan el evento denominado eventName
.
Si listener
se proporciona, devolverá cuántas veces se encuentra el agente de escucha en la lista de agentes de escucha del evento.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Parámetros
- eventName
-
string | symbol
Nombre del evento que se está escuchando
- listener
-
Function
Función del controlador de eventos
Devoluciones
number
Heredado de InternalClient.listenerCount
listeners<K>(string | symbol)
Devuelve una copia de la matriz de agentes de escucha para el evento denominado 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
Devoluciones
Function[]
Heredado 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
Devoluciones
Heredado 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
Devuelve un AsyncIterator
objeto que recorre en iteración los eventName
eventos. Se producirá si EventEmitter
emite 'error'
. Quita todos los agentes de escucha al salir del bucle. La value
propiedad devuelta por cada iteración es una matriz compuesta por los argumentos de evento emitidos.
AbortSignal
Se puede usar para cancelar la 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
Nombre del evento que se está escuchando
- options
-
StaticEventEmitterOptions
Devoluciones
AsyncIterableIterator<any>
que AsyncIterator
recorre en iteración los eventos emitidos eventName
por emitter
Heredado de InternalClient.on
on<K>(string | symbol, (args: any[]) => void)
Agrega la listener
función al final de la matriz de agentes de escucha para el evento denominado eventName
. No se realizan comprobaciones para ver si ya se ha agregado .listener
Varias llamadas que pasan la misma combinación de eventName
y listener
darán lugar a que listener
se agregue y se llame varias veces.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependListener()
método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.
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
Nombre del evento.
- listener
-
(args: any[]) => void
Función de devolución de llamada
Devoluciones
Heredado de InternalClient.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
Crea un Promise
objeto que se cumple cuando EventEmitter
emite el evento especificado o que se rechaza si emite EventEmitter
'error'
mientras espera.
Se Promise
resolverá con una matriz de todos los argumentos emitidos para el evento especificado.
Este método es genérico intencionadamente y funciona con la interfaz EventTarget de la plataforma web, que no tiene semántica de eventos especiales'error'
y no escucha el '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);
}
El control especial del 'error'
evento solo se usa cuando events.once()
se usa para esperar a otro evento. Si events.once()
se usa para esperar al propio evento 'error'
, se trata como cualquier otro tipo de evento sin control 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
Se AbortSignal
puede usar para cancelar la espera del 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
Devoluciones
Promise<any[]>
Heredado 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
Devoluciones
Promise<any[]>
Heredado de InternalClient.once
once<K>(string | symbol, (args: any[]) => void)
Agrega una función únicalistener
para el evento denominado eventName
. La próxima vez eventName
que se desencadene, se quita este agente de escucha y, a continuación, se invoca.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El emitter.prependOnceListener()
método se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.
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
Nombre del evento.
- listener
-
(args: any[]) => void
Función de devolución de llamada
Devoluciones
Heredado de InternalClient.once
open()
function open(): Promise<Connected>
Devoluciones
Promise<Connected>
Heredado de InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Parámetros
- openCallback
-
Callback<Connected>
Heredado de InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Agrega la listener
función al principio de la matriz de agentes de escucha para el evento denominado eventName
. No se realizan comprobaciones para ver si ya se ha agregado .listener
Varias llamadas que pasan la misma combinación de eventName
y listener
darán lugar a que listener
se agregue y se llame varias veces.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parámetros
- eventName
-
string | symbol
Nombre del evento.
- listener
-
(args: any[]) => void
Función de devolución de llamada
Devoluciones
Heredado de InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Agrega una función únicalistener
para el evento denominado eventName
al principio de la matriz de agentes de escucha. La próxima vez eventName
que se desencadene, se quita este agente de escucha y, a continuación, se invoca.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parámetros
- eventName
-
string | symbol
Nombre del evento.
- listener
-
(args: any[]) => void
Función de devolución de llamada
Devoluciones
Heredado de InternalClient.prependOnceListener
rawListeners<K>(string | symbol)
Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName
, incluidos los contenedores (como los creados 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
Devoluciones
Function[]
Heredado de InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Parámetros
- message
- Message
Devoluciones
Promise<MessageRejected>
Heredado de InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Parámetros
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
Heredado de InternalClient.reject
removeAllListeners(string | symbol)
Quita todos los agentes de escucha o los del especificado eventName
.
No es recomendable quitar los agentes de escucha agregados en otro lugar del código, especialmente cuando la EventEmitter
instancia se creó mediante algún otro componente o módulo (por ejemplo, sockets o secuencias de archivos).
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
function removeAllListeners(eventName?: string | symbol): Client
Parámetros
- eventName
-
string | symbol
Devoluciones
Heredado de InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Quita el especificado listener
de la matriz del agente de escucha para el evento denominado eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
quitará, como máximo, una instancia de un agente de escucha de la matriz del agente de escucha. Si se ha agregado un único agente de escucha varias veces a la matriz del agente de escucha para el especificado eventName
, removeListener()
se debe llamar varias veces para quitar cada instancia.
Una vez emitido un evento, todos los agentes de escucha adjuntos a él en el momento de emitir se llaman en orden. Esto implica que cualquier removeListener()
llamada o removeAllListeners()
después de emitir y antes de que el último agente de escucha finalice la ejecución no los quitará deemit()
en curso. Los eventos posteriores se comportan según lo previsto.
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
Dado que los agentes de escucha se administran mediante una matriz interna, llamar a esto cambiará los índices de posición de cualquier agente de escucha registrado después de quitar el agente de escucha. Esto no afectará al orden en el que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el emitter.listeners()
método deberán volver a crearse.
Cuando se haya agregado una sola función como controlador varias veces para un único evento (como en el ejemplo siguiente), removeListener()
quitará la instancia agregada más recientemente. En el ejemplo, se quita el once('ping')
agente de escucha:
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');
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parámetros
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Devoluciones
Heredado de InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Parámetros
- message
- Message
Devoluciones
Promise<MessageEnqueued>
Heredado de InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Parámetros
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
Heredado de InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Parámetros
- messages
-
Message[]
Devoluciones
Promise<MessageEnqueued>
Heredado de InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Parámetros
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
Heredado de InternalClient.sendEventBatch
setMaxListeners(number)
De forma predeterminada EventEmitter
, s imprimirá una advertencia si se agregan más 10
de agentes de escucha para un evento determinado. Este es un valor predeterminado útil que ayuda a encontrar fugas de memoria. El emitter.setMaxListeners()
método permite modificar el límite para esta instancia específica EventEmitter
. El valor se puede establecer en Infinity
(o 0
) para indicar un número ilimitado de agentes de escucha.
Devuelve una referencia a EventEmitter
, para que las llamadas se puedan encadenar.
function setMaxListeners(n: number): Client
Parámetros
- n
-
number
Devoluciones
Heredado 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
Número no negativo. Número máximo de agentes de escucha por EventTarget
evento.
- eventTargets
-
(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]
Heredado de InternalClient.setMaxListeners
setRetryPolicy(RetryPolicy)
Establece la directiva de reintento usada por el cliente en todas las operaciones. El valor predeterminado es ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Parámetros
- policy
-
RetryPolicy
{RetryPolicy} Directiva de reintentos que se debe usar para todas las operaciones futuras.
Heredado de InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Parámetros
- options
-
any
Devoluciones
Promise<TransportConfigured>
Heredado de InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Parámetros
- options
-
any
- done
-
Callback<TransportConfigured>
Heredado de InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Parámetros
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
Heredado 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
Heredado de InternalClient.__@captureRejectionSymbol@138