Client class
hub IoT client del dispositivo usato per connettere un dispositivo a un hub IoT di Azure.
Gli utenti dell'SDK devono chiamare uno dei metodi factory, daConnectionString o daSharedAccessSignature per creare un client del dispositivo hub IoT.
- Extends
-
InternalClient
Costruttori
Client(Device |
Proprietà ereditate
capture |
Valore: booleano Modificare l'opzione predefinita |
capture |
Valore: Vedere come scrivere un oggetto personalizzato |
default |
Per impostazione predefinita, è possibile registrare un massimo di Prestare attenzione quando si imposta l'oggetto Questo non è un limite rigido. L'istanza
Il L'avviso generato può essere controllato con |
error |
Questo simbolo deve essere utilizzato per installare un listener solo per gli eventi di monitoraggio L'installazione di un listener con questo simbolo non modifica il comportamento dopo l'emissione di un |
Metodi
close() | |
close(Callback<Disconnected>) | Chiude la connessione di trasporto e elimina definitivamente le risorse client. Nota: dopo aver chiamato questo metodo, l'oggetto Client non può essere riutilizzato. |
from |
Crea un client del dispositivo hub IoT dal metodo di autenticazione specificato e usando il tipo di trasporto specificato. |
from |
Crea un client del dispositivo hub IoT dal stringa di connessione specificato usando il tipo di trasporto specificato. |
from |
Crea un client del dispositivo hub IoT dalla firma di accesso condiviso specificata usando il tipo di trasporto specificato. |
get |
|
get |
Ottiene |
notify |
|
notify |
Il |
on |
Registra un callback per un metodo denominato |
set |
|
set |
|
upload |
|
upload |
Il |
Metodi ereditati
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Ascolta una sola volta l'evento nell'oggetto L'ascolto dell'evento Questa API consente l'uso Restituisce un oggetto monouso in modo che possa essere annullata più facilmente.
|
add |
Alias per |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Chiama in modo sincrono ognuno dei listener registrati per l'evento denominato Restituisce
|
event |
Restituisce una matrice che elenca gli eventi per i quali l'emittente ha registrato listener. I valori della matrice sono stringhe o
|
get |
Restituisce una copia della matrice di listener per l'evento denominato Per Per
|
get |
Restituisce il valore del listener massimo corrente per il |
get |
Restituisce la quantità massima attualmente impostata di listener. Per Per
|
get |
|
get |
|
listener |
Metodo di classe che restituisce il numero di listener per il dato registrato nell'oggetto
|
listener |
Restituisce il numero di listener in ascolto dell'evento denominato |
listeners<K>(string | symbol) | Restituisce una copia della matrice di listener per l'evento denominato
|
off<K>(string | symbol, (args: any[]) => void) | Alias per |
on(Event |
Restituisce un oggetto Può
|
on<K>(string | symbol, (args: any[]) => void) | Aggiunge la
Restituisce un riferimento a Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il
|
once(Event |
Crea un Questo metodo è intenzionalmente generico e funziona con l'interfaccia EventTarget della piattaforma Web, che non ha semantica di eventi speciali
La gestione speciale dell'evento
Un
|
once(Event |
|
once<K>(string | symbol, (args: any[]) => void) | Aggiunge una funzione una sola volta
Restituisce un riferimento a Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il
|
open() | |
open(Callback<Connected>) | |
prepend |
Aggiunge la
Restituisce un riferimento a |
prepend |
Aggiunge una funzione una sola volta
Restituisce un riferimento a |
raw |
Restituisce una copia della matrice di listener per l'evento denominato
|
reject(Message) | |
reject(Message, Callback<Message |
|
remove |
Rimuove tutti i listener o quelli dell'oggetto specificato È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza Restituisce un riferimento a |
remove |
Rimuove l'oggetto specificato
Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi
Poiché i listener vengono gestiti tramite una matrice interna, la chiamata di questa operazione modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente),
Restituisce un riferimento a |
send |
|
send |
|
send |
|
send |
|
set |
Per impostazione predefinita Restituisce un riferimento a |
set |
|
set |
Imposta i criteri di ripetizione dei tentativi usati dal client in tutte le operazioni. Il valore predefinito è ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
Dettagli costruttore
Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)
new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)
Parametri
- transport
- DeviceTransport
Oggetto che implementa l'interfaccia prevista da un oggetto di trasporto, ad esempio Http.
- connStr
-
string
Un stringa di connessione (facoltativo: se non specificato, updateSharedAccessSignature deve essere chiamato per impostare direttamente il token SharedAccessSignature).
- blobUploadClient
-
BlobUploadClient
Oggetto in grado di caricare un flusso in un BLOB.
- fileUploadApi
-
FileUploadInterface
Oggetto utilizzato per comunicare con hub IoT per le azioni correlate all'archiviazione BLOB.
Dettagli proprietà ereditate
captureRejections
Valore: booleano
Modificare l'opzione predefinita captureRejections
per tutti i nuovi EventEmitter
oggetti.
static captureRejections: boolean
Valore della proprietà
boolean
Ereditato da InternalClient.captureRejections
captureRejectionSymbol
Valore: Symbol.for('nodejs.rejection')
Vedere come scrivere un oggetto personalizzato rejection handler
.
static captureRejectionSymbol: typeof captureRejectionSymbol
Valore della proprietà
typeof captureRejectionSymbol
Ereditato da InternalClient.captureRejectionSymbol
defaultMaxListeners
Per impostazione predefinita, è possibile registrare un massimo di 10
listener per qualsiasi singolo evento. Questo limite può essere modificato per le singole EventEmitter
istanze usando il emitter.setMaxListeners(n)
metodo . Per modificare l'impostazione predefinita per tutte leEventEmitter
istanze, è possibile usare la events.defaultMaxListeners
proprietà . Se questo valore non è un numero positivo, viene generata un'eccezione RangeError
.
Prestare attenzione quando si imposta l'oggetto events.defaultMaxListeners
perché la modifica influisce su tutte leEventEmitter
istanze, incluse quelle create prima che venga apportata la modifica. Tuttavia, la chiamata emitter.setMaxListeners(n)
ha ancora la precedenza su events.defaultMaxListeners
.
Questo non è un limite rigido. L'istanza EventEmitter
consentirà di aggiungere più listener, ma restituirà un avviso di traccia a stderr che indica che è stata rilevata una possibile perdita di memoria EventEmitter. Per qualsiasi singolo EventEmitter
, è possibile usare i emitter.getMaxListeners()
metodi e emitter.setMaxListeners()
per evitare temporaneamente questo avviso:
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));
});
Il --trace-warnings
flag della riga di comando può essere usato per visualizzare l'analisi dello stack per tali avvisi.
L'avviso generato può essere controllato con process.on('warning')
e avrà le proprietà aggiuntive emitter
, type
e count
, facendo riferimento all'istanza dell'emettitore dell'evento, al nome dell'evento e al numero di listener collegati, rispettivamente.
La proprietà name
è impostata su 'MaxListenersExceededWarning'
.
static defaultMaxListeners: number
Valore della proprietà
number
Ereditato da InternalClient.defaultMaxListeners
errorMonitor
Questo simbolo deve essere utilizzato per installare un listener solo per gli eventi di monitoraggio 'error'
. I listener installati usando questo simbolo vengono chiamati prima che vengano chiamati i listener normali 'error'
.
L'installazione di un listener con questo simbolo non modifica il comportamento dopo l'emissione di un 'error'
evento. Pertanto, il processo continuerà ad arrestarsi in modo anomalo se non è installato alcun listener normale 'error'
.
static errorMonitor: typeof errorMonitor
Valore della proprietà
typeof errorMonitor
Ereditato da InternalClient.errorMonitor
Dettagli metodo
close()
function close(): Promise<Disconnected>
Restituisce
Promise<Disconnected>
close(Callback<Disconnected>)
Chiude la connessione di trasporto e elimina definitivamente le risorse client.
Nota: dopo aver chiamato questo metodo, l'oggetto Client non può essere riutilizzato.
function close(closeCallback?: Callback<Disconnected>)
Parametri
- closeCallback
-
Callback<Disconnected>
Funzione facoltativa da chiamare dopo la disconnessione del trasporto e la chiusura del client.
fromAuthenticationProvider(AuthenticationProvider, any)
Crea un client del dispositivo hub IoT dal metodo di autenticazione specificato e usando il tipo di trasporto specificato.
static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client
Parametri
- authenticationProvider
-
AuthenticationProvider
Oggetto usato per ottenere i parametri di autenticazione per l'hub IoT.
- transportCtor
-
any
Protocollo di trasporto usato per connettersi all'hub IoT.
Restituisce
fromConnectionString(string, any)
Crea un client del dispositivo hub IoT dal stringa di connessione specificato usando il tipo di trasporto specificato.
static function fromConnectionString(connStr: string, transportCtor: any): Client
Parametri
- connStr
-
string
Oggetto stringa di connessione che incapsula le autorizzazioni di "connessione del dispositivo" in un hub IoT.
- transportCtor
-
any
Costruttore di trasporto.
Restituisce
fromSharedAccessSignature(string, any)
Crea un client del dispositivo hub IoT dalla firma di accesso condiviso specificata usando il tipo di trasporto specificato.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client
Parametri
- sharedAccessSignature
-
string
Firma di accesso condiviso che incapsula le autorizzazioni di "connessione del dispositivo" in un hub IoT.
- transportCtor
-
any
Restituisce
getBlobSharedAccessSignature(string)
function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>
Parametri
- blobName
-
string
Restituisce
Promise<UploadParams>
getBlobSharedAccessSignature(string, Callback<UploadParams>)
Ottiene getBlobSharedAccessSignature
il token di firma di accesso condiviso dell'account di archiviazione collegato da hub IoT
function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)
Parametri
- blobName
-
string
Nome da usare per il BLOB che verrà creato con il contenuto del flusso.
- callback
-
Callback<UploadParams>
Callback facoltativo da chiamare al termine del caricamento.
notifyBlobUploadStatus(string, boolean, number, string)
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>
Parametri
- correlationId
-
string
- isSuccess
-
boolean
- statusCode
-
number
- statusDescription
-
string
Restituisce
Promise<void>
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)
Il notifyBlobUploadStatus
metodo invia hub IoT il risultato di un caricamento BLOB.
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)
Parametri
- correlationId
-
string
ID per correlare lo stato di caricamento in un BLOB specifico. Generato durante la chiamata a getBlobSharedAccessSignature
.
- isSuccess
-
boolean
Stato di esito positivo o negativo del risultato dell'operazione BLOB di archiviazione.
- statusCode
-
number
Codice di stato HTTP associato al risultato del BLOB di archiviazione.
- statusDescription
-
string
Descrizione del codice di stato HTTP.
- callback
-
ErrorCallback
Callback facoltativo da chiamare al termine del caricamento.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Registra un callback per un metodo denominato methodName
.
function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Parametri
- methodName
-
string
Nome del metodo che verrà gestito dal callback
- callback
-
(request: DeviceMethodRequest, response: DeviceMethodResponse) => void
Funzione che deve essere chiamata ogni volta che viene ricevuta una richiesta di metodo per il metodo chiamato methodName
.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Parametri
- options
- DeviceClientOptions
Restituisce
Promise<TransportConfigured>
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
function setOptions(options: DeviceClientOptions, done: Callback<TransportConfigured>)
Parametri
- options
- DeviceClientOptions
- done
-
Callback<TransportConfigured>
uploadToBlob(string, Stream, number)
function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>
Parametri
- blobName
-
string
- stream
-
Stream
- streamLength
-
number
Restituisce
Promise<void>
uploadToBlob(string, Stream, number, ErrorCallback)
Il uploadToBlob
metodo carica un flusso in un BLOB.
function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)
Parametri
- blobName
-
string
Nome da usare per il BLOB che verrà creato con il contenuto del flusso.
- stream
-
Stream
I dati in che devono essere caricati nel BLOB.
- streamLength
-
number
Dimensioni dei dati in che devono essere caricati nel BLOB.
- callback
-
ErrorCallback
Dettagli dei metodi ereditati
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Parametri
- message
- Message
Restituisce
Promise<MessageAbandoned>
Ereditato da InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Parametri
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
Ereditato da InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Ascolta una sola volta l'evento nell'oggetto abort
specificato signal
.
L'ascolto dell'evento abort
sui segnali di interruzione non è sicuro e può causare perdite di risorse poiché un'altra terza parte con il segnale può chiamare e.stopImmediatePropagation()
. Purtroppo Node.js non può modificare questo perché viola lo standard Web. Inoltre, l'API originale semplifica la rimozione dei listener.
Questa API consente l'uso AbortSignal
sicuro di s nelle API Node.js risolvendo questi due problemi ascoltando l'evento in modo che stopImmediatePropagation
non impedisca l'esecuzione del listener.
Restituisce un oggetto monouso in modo che possa essere annullata più 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
Parametri
- signal
-
AbortSignal
- resource
-
(event: Event) => void
Restituisce
Disposable
Monouso che rimuove il abort
listener.
Ereditato da InternalClient.addAbortListener
addListener<K>(string | symbol, (args: any[]) => void)
Alias per emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametri
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Restituisce
Ereditato da InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Parametri
- message
- Message
Restituisce
Promise<MessageCompleted>
Ereditato da InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Parametri
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
Ereditato da InternalClient.complete
emit<K>(string | symbol, AnyRest)
Chiama in modo sincrono ognuno dei listener registrati per l'evento denominato eventName
, nell'ordine in cui sono stati registrati, passando gli argomenti forniti a ognuno.
Restituisce true
se l'evento aveva listener, false
in caso contrario.
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
Parametri
- eventName
-
string | symbol
- args
-
AnyRest
Restituisce
boolean
Ereditato da InternalClient.emit
eventNames()
Restituisce una matrice che elenca gli eventi per i quali l'emittente ha registrato listener. I valori della matrice sono stringhe 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)[]
Restituisce
(string | symbol)[]
Ereditato da InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)
Restituisce una copia della matrice di listener per l'evento denominato eventName
.
Per EventEmitter
questo comportamento si comporta esattamente come la chiamata .listeners
sull'emittente.
Per EventTarget
s questo è l'unico modo per ottenere i listener di eventi per la destinazione dell'evento. Ciò è utile per scopi di debug e diagnostica.
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[]
Parametri
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
- name
-
string | symbol
Restituisce
Function[]
Ereditato da InternalClient.getEventListeners
getMaxListeners()
Restituisce il valore del listener massimo corrente per il EventEmitter
quale è impostato per emitter.setMaxListeners(n)
impostazione predefinita o per defaultMaxListeners.
function getMaxListeners(): number
Restituisce
number
Ereditato da InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
Restituisce la quantità massima attualmente impostata di listener.
Per EventEmitter
questo comportamento si comporta esattamente come la chiamata .getMaxListeners
sull'emittente.
Per EventTarget
s questo è l'unico modo per ottenere i listener di eventi max per la destinazione dell'evento. Se il numero di gestori eventi in un singolo EventTarget supera il set massimo, EventTarget visualizzerà un avviso.
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
Parametri
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
Restituisce
number
Ereditato da InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Parametri
- done
-
Callback<Twin>
Ereditato da InternalClient.getTwin
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Avviso
Questa API è ora deprecata.
Since v3.2.0 - Use listenerCount
instead.
Metodo di classe che restituisce il numero di listener per il dato registrato nell'oggetto eventName
specificato 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
Parametri
- emitter
-
EventEmitter<DefaultEventMap>
L'emittente da eseguire una query
- eventName
-
string | symbol
Nome evento
Restituisce
number
Ereditato da InternalClient.listenerCount
listenerCount<K>(string | symbol, Function)
Restituisce il numero di listener in ascolto dell'evento denominato eventName
.
Se listener
viene specificato, restituirà il numero di volte in cui viene trovato il listener nell'elenco dei listener dell'evento.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Parametri
- eventName
-
string | symbol
Nome dell'evento in ascolto
- listener
-
Function
Funzione del gestore eventi
Restituisce
number
Ereditato da InternalClient.listenerCount
listeners<K>(string | symbol)
Restituisce una copia della matrice di listener per l'evento denominato 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[]
Parametri
- eventName
-
string | symbol
Restituisce
Function[]
Ereditato da InternalClient.listener
off<K>(string | symbol, (args: any[]) => void)
Alias per emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametri
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Restituisce
Ereditato da 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
Restituisce un oggetto AsyncIterator
che esegue l'iterazione degli eventName
eventi. Genererà se l'oggetto EventEmitter
genera 'error'
. Rimuove tutti i listener quando si chiude il ciclo. L'oggetto value
restituito da ogni iterazione è una matrice composta dagli argomenti dell'evento generati.
Può AbortSignal
essere usato per annullare l'attesa sugli eventi:
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>
Parametri
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string
Nome dell'evento in ascolto
- options
-
StaticEventEmitterOptions
Restituisce
AsyncIterableIterator<any>
Oggetto AsyncIterator
che esegue l'iterazione degli eventName
eventi generati dall'oggetto emitter
Ereditato da InternalClient.on
on<K>(string | symbol, (args: any[]) => void)
Aggiunge la listener
funzione alla fine della matrice listener per l'evento denominato eventName
. Non vengono effettuati controlli per verificare se l'oggetto listener
è già stato aggiunto. Più chiamate passando la stessa combinazione di eventName
e listener
comportano l'aggiunta listener
e la chiamata, più volte.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependListener()
metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei listener.
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
Parametri
- eventName
-
string | symbol
Nome dell'evento.
- listener
-
(args: any[]) => void
Funzione di callback
Restituisce
Ereditato da InternalClient.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
Crea un Promise
oggetto che viene soddisfatto quando l'oggetto EventEmitter
genera l'evento specificato o che viene rifiutato se l'oggetto genera 'error'
durante l'attesaEventEmitter
.
Verrà Promise
risolto con una matrice di tutti gli argomenti generati all'evento specificato.
Questo metodo è intenzionalmente generico e funziona con l'interfaccia EventTarget della piattaforma Web, che non ha semantica di eventi speciali'error'
e non ascolta l'evento 'error'
.
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);
}
La gestione speciale dell'evento 'error'
viene utilizzata solo quando events.once()
viene usata per attendere un altro evento. Se events.once()
viene usato per attendere l'evento 'error'
stesso, viene considerato come qualsiasi altro tipo di evento senza gestione speciale:
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
Un AbortSignal
oggetto può essere usato per annullare l'attesa dell'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[]>
Parametri
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
Restituisce
Promise<any[]>
Ereditato da InternalClient.una volta
once(EventTarget, string, StaticEventEmitterOptions)
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Parametri
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Restituisce
Promise<any[]>
Ereditato da InternalClient.una volta
once<K>(string | symbol, (args: any[]) => void)
Aggiunge una funzione una sola voltalistener
per l'evento denominato eventName
. La volta successiva eventName
viene attivata, questo listener viene rimosso e quindi richiamato.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependOnceListener()
metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei listener.
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
Parametri
- eventName
-
string | symbol
Nome dell'evento.
- listener
-
(args: any[]) => void
Funzione di callback
Restituisce
Ereditato da InternalClient.una volta
open()
function open(): Promise<Connected>
Restituisce
Promise<Connected>
Ereditato da InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Parametri
- openCallback
-
Callback<Connected>
Ereditato da InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Aggiunge la listener
funzione all'inizio della matrice listener per l'evento denominato eventName
. Non vengono effettuati controlli per verificare se l'oggetto listener
è già stato aggiunto. Più chiamate passando la stessa combinazione di eventName
e listener
comportano l'aggiunta listener
e la chiamata, più volte.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametri
- eventName
-
string | symbol
Nome dell'evento.
- listener
-
(args: any[]) => void
Funzione di callback
Restituisce
Ereditato da InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Aggiunge una funzione una sola voltalistener
per l'evento denominato eventName
all'inizio della matrice listener. La volta successiva eventName
viene attivata, questo listener viene rimosso e quindi richiamato.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametri
- eventName
-
string | symbol
Nome dell'evento.
- listener
-
(args: any[]) => void
Funzione di callback
Restituisce
Ereditato da InternalClient.prependOnceListener
rawListeners<K>(string | symbol)
Restituisce una copia della matrice di listener per l'evento denominato eventName
, inclusi i wrapper ( ad esempio quelli creati da .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[]
Parametri
- eventName
-
string | symbol
Restituisce
Function[]
Ereditato da InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Parametri
- message
- Message
Restituisce
Promise<MessageRejected>
Ereditato da InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Parametri
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
Ereditato da InternalClient.reject
removeAllListeners(string | symbol)
Rimuove tutti i listener o quelli dell'oggetto specificato eventName
.
È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza EventEmitter
è stata creata da un altro componente o modulo ,ad esempio socket o flussi di file.
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
function removeAllListeners(eventName?: string | symbol): Client
Parametri
- eventName
-
string | symbol
Restituisce
Ereditato da InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Rimuove l'oggetto specificato listener
dalla matrice del listener per l'evento denominato eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice del listener per l'oggetto specificato eventName
, removeListener()
è necessario chiamare più volte per rimuovere ogni istanza.
Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener()
chiamata o removeAllListeners()
dopo l'emissione e prima che l'ultimo listener finisca l'esecuzione non li rimuoverà daemit()
in corso. Gli eventi successivi si comportano come 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
Poiché i listener vengono gestiti tramite una matrice interna, la chiamata di questa operazione modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal emitter.listeners()
metodo dovranno essere ricreate.
Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), removeListener()
rimuoverà l'istanza aggiunta più di recente. Nell'esempio il once('ping')
listener viene rimosso:
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');
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametri
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Restituisce
Ereditato da InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Parametri
- message
- Message
Restituisce
Promise<MessageEnqueued>
Ereditato da InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Parametri
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
Ereditato da InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Parametri
- messages
-
Message[]
Restituisce
Promise<MessageEnqueued>
Ereditato da InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Parametri
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
Ereditato da InternalClient.sendEventBatch
setMaxListeners(number)
Per impostazione predefinita EventEmitter
, verrà visualizzato un avviso se vengono aggiunti più 10
listener per un determinato evento. Si tratta di un valore predefinito utile che consente di trovare perdite di memoria. Il emitter.setMaxListeners()
metodo consente di modificare il limite per questa istanza specifica EventEmitter
. Il valore può essere impostato su Infinity
(o 0
) per indicare un numero illimitato di listener.
Restituisce un riferimento a EventEmitter
, in modo che le chiamate possano essere concatenati.
function setMaxListeners(n: number): Client
Parametri
- n
-
number
Restituisce
Ereditato da 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)[])
Parametri
- n
-
number
Numero non negativo. Numero massimo di listener per EventTarget
evento.
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
Ereditato da InternalClient.setMaxListeners
setRetryPolicy(RetryPolicy)
Imposta i criteri di ripetizione dei tentativi usati dal client in tutte le operazioni. Il valore predefinito è ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Parametri
- policy
-
RetryPolicy
{RetryPolicy} Criteri di ripetizione dei tentativi da usare per tutte le operazioni future.
Ereditato da InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Parametri
- options
-
any
Restituisce
Promise<TransportConfigured>
Ereditato da InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Parametri
- options
-
any
- done
-
Callback<TransportConfigured>
Ereditato da InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Parametri
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
Ereditato da InternalClient.updateSharedAccessSignature
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Parametri
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
Ereditato da InternalClient.__@captureRejectionSymbol@138