你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站,请访问 https://docs.azure.cn。
Client class
IoT 中心服务客户端用于通过 Azure IoT 中心与设备通信。 它允许 SDK 用户:
- 将云到设备 (也称为命令) 发送到设备:命令在IoT 中心排队,仅在设备连接时以异步方式传递。 每个设备只能排队 50 个命令。
- 在设备上调用直接方法 (,仅当设备当前已连接时才有效:这是与设备通信的同步方式)
- 侦听设备针对先前命令发送的反馈消息。
- 侦听来自设备的文件上传通知。
用户应通过调用工厂方法之一(从ConnectionString 或 fromSharedAccessSignature)Client创建新实例,以创建IoT 中心服务客户端。
- Extends
-
EventEmitter
继承属性
capture |
值: 布尔值 更改所有新 |
capture |
值: 了解如何编写自定义 |
default |
默认情况下,可以为任何单个事件注册最多 设置 时请小心, 这不是硬性限制。 实例
可以使用 |
error |
此符号应用于安装仅监视 使用此符号安装侦听器不会在发出事件后 |
方法
继承的方法
add |
侦听提供的 侦听中止信号上的 此 API 允许在 Node.js API 中安全地使用 返回一个可释放项,以便可以更轻松地取消订阅。
|
add |
|
emit<K>(string | symbol, Any |
按照注册顺序同步调用为名为
|
event |
返回一个数组,其中列出了发射器为其注册了侦听器的事件。 数组中的值为字符串或
|
get |
返回名为 对于 对于
|
get |
返回 的当前最大侦听器值, |
get |
返回当前设置的最大侦听器数。 对于 对于
|
listener |
一个类方法,用于返回在给定 上注册的给定
|
listener |
返回侦听名为 |
listeners<K>(string | symbol) | 返回名为
|
off<K>(string | symbol, (args: any[]) => void) |
|
on(Event |
返回一个
|
on<K>(string | symbol, (args: any[]) => void) | 将
返回对 的引用, 默认情况下,事件侦听器按添加顺序调用。 方法
|
once(Event |
创建一个在 此方法是有意通用的,适用于 Web 平台 EventTarget 接口,该接口没有特殊
仅当 用于等待另一个事件时
|
once(Event |
|
once<K>(string | symbol, (args: any[]) => void) | 为名为
返回对 的引用, 默认情况下,事件侦听器按添加顺序调用。 方法
|
prepend |
将
返回对 的引用, |
prepend |
将名为
返回对 的引用, |
raw |
返回名为
|
remove |
删除所有侦听器或指定 删除代码中其他位置添加的侦听器是错误的,尤其是当 返回对 的引用, |
remove |
从名为
发出事件后,将按顺序调用发出时附加到该事件的所有侦听器。 这意味着发出后和最后一个侦听器完成执行之前的任何
由于侦听器是使用内部数组管理的,因此调用此方法将更改删除侦听器 后 注册的任何侦听器的位置索引。 这不会影响调用侦听器的顺序,但这意味着需要重新创建方法返回 如果已多次将单个函数添加为单个事件的处理程序, (如下面的示例) 所示,
返回对 的引用, |
set |
默认情况下 返回对 的引用, |
set |
|
[capture |
继承属性详细信息
captureRejections
值: 布尔值
更改所有新EventEmitter
对象的默认captureRejections
选项。
static captureRejections: boolean
属性值
boolean
继承自 EventEmitter.captureRejections
captureRejectionSymbol
值:Symbol.for('nodejs.rejection')
了解如何编写自定义 rejection handler
。
static captureRejectionSymbol: typeof captureRejectionSymbol
属性值
typeof captureRejectionSymbol
继承自 EventEmitter.captureRejectionSymbol
defaultMaxListeners
默认情况下,可以为任何单个事件注册最多 10
侦听器。 可以使用 方法更改单个 EventEmitter
实例的 emitter.setMaxListeners(n)
此限制。 若要更改 所有EventEmitter
实例的默认值, events.defaultMaxListeners
可以使用 属性。 如果此值不是正数, RangeError
则会引发 。
设置 时请小心, events.defaultMaxListeners
因为更改会影响 所有EventEmitter
实例,包括在进行更改之前创建的实例。 但是,调用 emitter.setMaxListeners(n)
仍然优先于 events.defaultMaxListeners
。
这不是硬性限制。 实例 EventEmitter
将允许添加更多侦听器,但会向 stderr 输出跟踪警告,指示已检测到“可能的 EventEmitter 内存泄漏”。 对于任何单个 EventEmitter
, emitter.getMaxListeners()
和 emitter.setMaxListeners()
方法都可用于暂时避免此警告:
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));
});
--trace-warnings
命令行标志可用于显示此类警告的堆栈跟踪。
可以使用 process.on('warning')
检查发出的警告,并将具有额外的 emitter
、 type
和 count
属性,分别引用事件发射器实例、事件的名称和附加的侦听器数。
其 name
属性设置为 'MaxListenersExceededWarning'
。
static defaultMaxListeners: number
属性值
number
继承自 EventEmitter.defaultMaxListeners
errorMonitor
此符号应用于安装仅监视 'error'
事件的侦听器。 使用此符号安装的侦听器在调用常规 'error'
侦听器之前调用。
使用此符号安装侦听器不会在发出事件后 'error'
更改行为。 因此,如果未安装常规 'error'
侦听器,进程仍将崩溃。
static errorMonitor: typeof errorMonitor
属性值
typeof errorMonitor
继承自 EventEmitter.errorMonitor
方法详细信息
close()
function close(): Promise<ResultWithIncomingMessage<Disconnected>>
返回
Promise<ResultWithIncomingMessage<Disconnected>>
close(IncomingMessageCallback<Disconnected>)
关闭与 IoT 中心的连接。
function close(done?: IncomingMessageCallback<Disconnected>)
参数
- done
-
IncomingMessageCallback<Disconnected>
操作完成时要调用的可选函数。 done
将传递 Error 对象参数,如果操作成功完成,该参数将为 null。
fromConnectionString(string, TransportCtor)
使用默认传输 (Amqp) 或第二个参数中指定的传输 (从给定连接字符串创建IoT 中心服务客户端。
static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client
参数
- connStr
-
string
封装 IoT 中心的“设备连接”权限的连接字符串。
- transportCtor
- TransportCtor
返回
fromSharedAccessSignature(string, TransportCtor)
使用默认传输 (Amqp) 或第二个参数中指定的传输,从给定的共享访问签名创建IoT 中心服务客户端。
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client
参数
- sharedAccessSignature
-
string
一个共享访问签名,用于封装 IoT 中心的“服务连接”权限。
- transportCtor
- TransportCtor
返回
fromTokenCredential(string, TokenCredential, TransportCtor)
使用默认传输 (Amqp) 或第二个参数中指定的传输,从给定的 Azure tokenCredential 创建IoT 中心服务客户端。
static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client
参数
- hostName
-
string
Azure 服务的主机名。
- tokenCredential
- TokenCredential
用于通过 Azure 服务进行身份验证的 Azure TokenCredential
- transportCtor
- TransportCtor
返回
getFeedbackReceiver()
function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>
返回
Promise<ResultWithIncomingMessage<ServiceReceiver>>
getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)
返回一个 AmqpReceiver 对象,该对象在客户端收到新的反馈消息时发出事件。
function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)
参数
- done
-
IncomingMessageCallback<ServiceReceiver>
操作完成时要调用的可选函数。 done
将使用两个参数调用: (Error 对象可为 null) 和 AmqpReceiver 对象。
getFileNotificationReceiver()
function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>
返回
Promise<ResultWithIncomingMessage<ServiceReceiver>>
getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)
返回一个 AmqpReceiver 对象,该对象在客户端收到新的文件上传通知时发出事件。
function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)
参数
- done
-
IncomingMessageCallback<ServiceReceiver>
操作完成时要调用的可选函数。 done
将使用两个参数调用: (Error 对象可为 null) 和 AmqpReceiver 对象。
invokeDeviceMethod(string, DeviceMethodParams)
function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>
参数
- deviceId
-
string
- methodParams
- DeviceMethodParams
返回
Promise<ResultWithIncomingMessage<any>>
invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)
在特定设备或模块上调用 方法。
function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)
参数
- deviceId
-
string
现有设备标识的标识符。
- methodParams
- DeviceMethodParams
- done
-
IncomingMessageCallback<any>
使用方法执行结果调用的可选回调。
invokeDeviceMethod(string, string, DeviceMethodParams)
function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>
参数
- deviceId
-
string
- moduleId
-
string
- methodParams
- DeviceMethodParams
返回
Promise<ResultWithIncomingMessage<any>>
invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>)
function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)
参数
- deviceId
-
string
- moduleId
-
string
- methodParams
- DeviceMethodParams
- done
-
IncomingMessageCallback<any>
open()
function open(): Promise<ResultWithIncomingMessage<Connected>>
返回
Promise<ResultWithIncomingMessage<Connected>>
open(IncomingMessageCallback<Connected>)
打开与 IoT 中心的连接。
function open(done?: IncomingMessageCallback<Connected>)
参数
- done
-
IncomingMessageCallback<Connected>
操作完成时要调用的可选函数。 done
将传递 Error 对象参数,如果操作成功完成,该参数将为 null。
send(string, Message | BufferConvertible)
function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>
参数
- deviceId
-
string
- message
-
Message | BufferConvertible
返回
Promise<ResultWithIncomingMessage<MessageEnqueued>>
send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)
向设备发送消息。
function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)
参数
- deviceId
-
string
现有设备标识的标识符。
- message
-
Message | BufferConvertible
要发送到设备的消息的正文。
如果 message
不是 Message 类型,则将转换它。
- done
-
IncomingMessageCallback<MessageEnqueued>
操作完成时要调用的可选函数。 done
将使用两个参数调用:错误对象 (可以为 null) ,以及一个特定于传输的响应对象(可用于日志记录或调试)。
setRetryPolicy(RetryPolicy)
设置客户端用于重试网络操作的策略。
function setRetryPolicy(policy: RetryPolicy)
参数
- policy
-
RetryPolicy
用于重试操作的策略 (例如。打开、发送等 ) 。 SDK 附带 2 个“内置”策略:ExponentialBackoffWithJitter (默认) 和 NoRetry (,用于取消任何形式的重试) 。 用户还可以传递自己的对象,只要它实现 2 种方法: - shouldRetry (err: 错误) : 布尔值 : 指示是否应根据错误类型重试操作 - nextRetryTimeout (retryCount: number, throttled: boolean) : number : 返回等待 (的时间(以毫秒为单位) ),然后根据过去重试次数 (retryCount) 以及错误是否为限制错误这一事实返回重试的时间(以毫秒为单位)。
继承的方法详细信息
addAbortListener(AbortSignal, (event: Event) => void)
侦听提供的 signal
上的事件一次abort
。
侦听中止信号上的 abort
事件不安全,并可能导致资源泄漏,因为另一个具有该信号的第三方可以调用 e.stopImmediatePropagation()
。 遗憾的是,Node.js 无法更改此内容,因为它会违反 Web 标准。 此外,使用原始 API 可以轻松删除侦听器。
此 API 允许在 Node.js API 中安全地使用 AbortSignal
,方法是通过侦听事件来解决这两个问题, stopImmediatePropagation
以免阻止侦听器运行。
返回一个可释放项,以便可以更轻松地取消订阅。
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
参数
- signal
-
AbortSignal
- resource
-
(event: Event) => void
返回
Disposable
删除侦听器的 abort
一次性对象。
继承自 EventEmitter.addAbortListener
addListener<K>(string | symbol, (args: any[]) => void)
emitter.on(eventName, listener)
的别名。
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
参数
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
返回
继承自 EventEmitter.addListener
emit<K>(string | symbol, AnyRest)
按照注册顺序同步调用为名为 eventName
的事件注册的每个侦听器,并将提供的参数传递给每个侦听器。
true
如果事件有侦听器,则返回 ;false
否则返回 。
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
参数
- eventName
-
string | symbol
- args
-
AnyRest
返回
boolean
继承自 EventEmitter.emit
eventNames()
返回一个数组,其中列出了发射器为其注册了侦听器的事件。 数组中的值为字符串或 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)[]
返回
(string | symbol)[]
继承自 EventEmitter.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)
返回名为 eventName
的事件的侦听器数组的副本。
对于 EventEmitter
,其行为与在发射器上调用 .listeners
的行为完全相同。
对于 EventTarget
,这是获取事件目标的事件侦听器的唯一方法。 这对于调试和诊断目的非常有用。
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[]
参数
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
- name
-
string | symbol
返回
Function[]
继承自 EventEmitter.getEventListeners
getMaxListeners()
返回 的当前最大侦听器值, EventEmitter
该值由 emitter.setMaxListeners(n)
或 默认设置为 defaultMaxListeners。
function getMaxListeners(): number
返回
number
继承自 EventEmitter.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
返回当前设置的最大侦听器数。
对于 EventEmitter
,其行为与在发射器上调用 .getMaxListeners
的行为完全相同。
对于 EventTarget
,这是获取事件目标的最大事件侦听器的唯一方法。 如果单个 EventTarget 上的事件处理程序数超过最大设置,则 EventTarget 将输出警告。
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
参数
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
返回
number
继承自 EventEmitter.getMaxListeners
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
警告
现已弃用此 API。
Since v3.2.0 - Use listenerCount
instead.
一个类方法,用于返回在给定 上注册的给定 eventName
的 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
参数
- emitter
-
EventEmitter<DefaultEventMap>
要查询的发射器
- eventName
-
string | symbol
事件名称
返回
number
继承自 EventEmitter.listenerCount
listenerCount<K>(string | symbol, Function)
返回侦听名为 eventName
的事件的侦听器数。
如果 listener
提供 ,它将返回在事件的侦听器列表中找到侦听器的次数。
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
参数
- eventName
-
string | symbol
正在侦听的事件的名称
- listener
-
Function
事件处理程序函数
返回
number
继承自 EventEmitter.listenerCount
listeners<K>(string | symbol)
返回名为 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[]
参数
- eventName
-
string | symbol
返回
Function[]
继承自 EventEmitter.listeners
off<K>(string | symbol, (args: any[]) => void)
emitter.removeListener()
的别名。
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
参数
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
返回
继承自 EventEmitter.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
返回一个 AsyncIterator
循环访问 eventName
事件的 。 如果 发出 'error'
,EventEmitter
则会引发 。 退出循环时,它会删除所有侦听器。 value
每次迭代返回的 是一个由发出的事件参数组成的数组。
AbortSignal
可用于取消等待事件:
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>
参数
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string
正在侦听的事件的名称
- options
-
StaticEventEmitterOptions
返回
AsyncIterableIterator<any>
一个 AsyncIterator
,它循环访问 eventName
由 发出的事件 emitter
继承自 EventEmitter.on
on<K>(string | symbol, (args: any[]) => void)
将 listener
函数添加到名为 eventName
的事件的侦听器数组的末尾。 不会检查是否已 listener
添加 。 传递 和 listener
的相同组合的eventName
多个调用将导致listener
多次添加和调用 。
server.on('connection', (stream) => {
console.log('someone connected!');
});
返回对 的引用, EventEmitter
以便可以链接调用。
默认情况下,事件侦听器按添加顺序调用。 方法 emitter.prependListener()
可用作将事件侦听器添加到侦听器数组开头的替代方法。
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
参数
- eventName
-
string | symbol
事件的名称。
- listener
-
(args: any[]) => void
回调函数
返回
继承自 EventEmitter.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
创建一个在 Promise
发出给定事件时 EventEmitter
完成的 ;如果 EventEmitter
发出等待事件,则会拒绝该事件 'error'
。
Promise
将使用发出给给定事件的所有参数的数组解析 。
此方法是有意通用的,适用于 Web 平台 EventTarget 接口,该接口没有特殊'error'
事件语义,并且不侦 '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);
}
仅当 用于等待另一个事件时events.once()
,才使用事件的特殊处理'error'
。 如果使用 events.once()
来等待 “error'
事件本身”,则会将其视为任何其他类型的事件,无需特殊处理:
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
AbortSignal
可用于取消等待事件:
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[]>
参数
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
返回
Promise<any[]>
继承自 EventEmitter.once
once(EventTarget, string, StaticEventEmitterOptions)
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
参数
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
返回
Promise<any[]>
继承自 EventEmitter.once
once<K>(string | symbol, (args: any[]) => void)
为名为 eventName
的事件添加一次性listener
函数。 下次触发时 eventName
,会删除此侦听器,然后调用。
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
返回对 的引用, EventEmitter
以便可以链接调用。
默认情况下,事件侦听器按添加顺序调用。 方法 emitter.prependOnceListener()
可用作将事件侦听器添加到侦听器数组开头的替代方法。
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
参数
- eventName
-
string | symbol
事件的名称。
- listener
-
(args: any[]) => void
回调函数
返回
继承自 EventEmitter.once
prependListener<K>(string | symbol, (args: any[]) => void)
将 listener
函数添加到名为 eventName
的事件的侦听器数组的开头。 不会检查是否已 listener
添加 。 传递 和 listener
的相同组合的eventName
多个调用将导致listener
多次添加和调用 。
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
返回对 的引用, EventEmitter
以便可以链接调用。
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
参数
- eventName
-
string | symbol
事件的名称。
- listener
-
(args: any[]) => void
回调函数
返回
继承自 EventEmitter.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
将名为 eventName
的事件的一次性listener
函数添加到侦听器数组的开头。 下次 eventName
触发时,会删除此侦听器,然后调用。
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
返回对 的引用, EventEmitter
以便可以链接调用。
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
参数
- eventName
-
string | symbol
事件的名称。
- listener
-
(args: any[]) => void
回调函数
返回
继承自 EventEmitter.prependOnceListener
rawListeners<K>(string | symbol)
返回名为 eventName
的事件的侦听器数组的副本,包括任何包装器 (,例如由) 创建的 .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[]
参数
- eventName
-
string | symbol
返回
Function[]
继承自 EventEmitter.rawListeners
removeAllListeners(string | symbol)
删除所有侦听器或指定 eventName
的侦听器。
删除代码中其他位置添加的侦听器是错误的,尤其是当 EventEmitter
实例是由某些其他组件或模块 ((例如套接字或文件流) )创建的。
返回对 的引用, EventEmitter
以便可以链接调用。
function removeAllListeners(eventName?: string | symbol): Client
参数
- eventName
-
string | symbol
返回
继承自 EventEmitter.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
从名为 eventName
的事件的侦听器数组中删除指定的 listener
。
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
最多会从侦听器数组中删除侦听器的一个实例。 如果已多次将任何单个侦听器添加到指定 eventName
的侦听器数组中,则必须 removeListener()
多次调用 以删除每个实例。
发出事件后,将按顺序调用发出时附加到该事件的所有侦听器。 这意味着发出后和最后一个侦听器完成执行之前的任何 removeListener()
或 removeAllListeners()
调用都不会将其从emit()
正在进行的中删除。 后续事件的行为符合预期。
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
由于侦听器是使用内部数组管理的,因此调用此方法将更改删除侦听器 后 注册的任何侦听器的位置索引。 这不会影响调用侦听器的顺序,但这意味着需要重新创建方法返回 emitter.listeners()
的侦听器数组的任何副本。
如果已多次将单个函数添加为单个事件的处理程序, (如下面的示例) 所示, removeListener()
将删除最近添加的实例。 在示例中, once('ping')
删除了侦听器:
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');
返回对 的引用, EventEmitter
以便可以链接调用。
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
参数
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
返回
继承自 EventEmitter.removeListener
setMaxListeners(number)
默认情况下 EventEmitter
,如果为特定事件添加了多个 10
侦听器,则会打印警告。 这是一个有用的默认值,可帮助查找内存泄漏。 方法 emitter.setMaxListeners()
允许修改此特定 EventEmitter
实例的限制。 该值可以设置为 Infinity
(或 0
) ,以指示无限数量的侦听器。
返回对 的引用, EventEmitter
以便可以链接调用。
function setMaxListeners(n: number): Client
参数
- n
-
number
返回
继承自 EventEmitter.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)[])
参数
- n
-
number
非负数。 每个 EventTarget
事件的最大侦听器数。
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
继承自 EventEmitter.setMaxListeners
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
参数
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
继承自 EventEmitter.__@captureRejectionSymbol@115