ModuleClient class

用于将设备连接到 Azure IoT 中心的 IoT 中心设备客户端。

SDK 的用户应调用工厂方法之一，FromConnectionString 或 fromSharedAccessSignature 来创建 IoT 中心设备客户端。

继承属性

captureRejections	值：布尔更改所有新`EventEmitter`对象的默认`captureRejections`选项。
captureRejectionSymbol	值：`Symbol.for('nodejs.rejection')` 看看如何编写自定义 `rejection handler`文档。
defaultMaxListeners	默认情况下，单个活动最多只能注册听 `10` 众人数。使用该`emitter.setMaxListeners(n)`方法可以针对单个`EventEmitter`实例更改该限制。要更改所有`EventEmitter` 实例的默认值，可以使用该 `events.defaultMaxListeners` 属性。如果该值不是正数，则抛出a `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'`。
errorMonitor	该符号用于安装仅用于监控 `'error'` 事件的监听器。使用该符号安装的监听器会在常规 `'error'` 监听器被调用之前被调用。使用该符号安装监听器不会改变事件一旦 `'error'` 发出的行为。因此，如果没有安装常规 `'error'` 监听器，进程仍然会崩溃。

方法

close()
close(Callback<Disconnected>)	关闭传输连接并销毁客户端资源。注意：调用此方法后，无法重复使用 ModuleClient 对象。
fromAuthenticationProvider(AuthenticationProvider, any)	从给定的身份验证方法并使用给定的传输类型创建 IoT 中心模块客户端。
fromConnectionString(string, any)	使用给定的传输类型从给定连接字符串创建 IoT 中心设备客户端。
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)	使用环境中的配置信息创建 IoT 中心模块客户端。如果存在名为 `EdgeHubConnectionString` 或 `IotHubConnectionString` 的环境变量，则使用该值，行为与调用传入 `fromConnectionString` 相同。如果这些环境变量不存在，则必须定义以下变量： `- IOTEDGE_WORKLOADURI URI for iotedged's workload API - IOTEDGE_DEVICEID Device identifier - IOTEDGE_MODULEID Module identifier - IOTEDGE_MODULEGENERATIONID Module generation identifier - IOTEDGE_IOTHUBHOSTNAME IoT Hub host name - IOTEDGE_AUTHSCHEME Authentication scheme to use; must be "sasToken"`
fromSharedAccessSignature(string, any)	使用给定的传输类型从给定的共享访问签名创建 IoT 中心模块客户端。
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)	在同一 IoTEdge 设备上调用下游设备或另一个模块上的方法。请注意，仅当模块作为 IoTEdge 设备的一部分运行时，此功能才有效。
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)	为名为 `methodName`的方法注册回调。
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)	将事件发送到给定模块输出
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)	将事件数组发送到给定的模块输出
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)	将选项传递给可用于配置传输的 `ModuleClient` 对象。

继承的方法

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)	在提供的`signal`网站上收听一次`abort`活动。在中止信号上监听 `abort` 事件是不安全的，可能导致资源泄漏，因为其他第三方可能呼叫 `e.stopImmediatePropagation()`。很遗憾，Node.js 无法更改这一点，因为这会违反网络标准。此外，原始API让人很容易忘记移除监听器。该 API 通过监听`stopImmediatePropagation`事件且不阻止监听者运行，从而安全地在 Node.js API 中使用 `AbortSignal`s。退回一次性产品，以便更容易取消订阅。 `import { addAbortListener } from 'node:events'; function example(signal) { let disposable; try { signal.addEventListener('abort', (e) => e.stopImmediatePropagation()); disposable = addAbortListener(signal, (e) => { // Do something when signal is aborted. }); } finally { disposable?.[Symbol.dispose](); } }`
addListener<K>(string \| symbol, (args: any[]) => void)	`emitter.on(eventName, listener)`的别名。
complete(Message)
complete(Message, Callback<MessageCompleted>)
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
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) ]`
getEventListeners(EventEmitter<DefaultEventMap> \| EventTarget, string \| symbol)	返回名为 `eventName`的事件的侦听器数组的副本。对于 `EventEmitter`s，这的行为与调用 `.listeners` 发射极完全相同。对于 `EventTarget`s，这是获得事件目标事件监听者的唯一方法。这对调试和诊断非常有用。 `import { getEventListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); const listener = () => console.log('Events are fun'); ee.on('foo', listener); console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ] } { const et = new EventTarget(); const listener = () => console.log('Events are fun'); et.addEventListener('foo', listener); console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ] }`
getMaxListeners()	返回由 `EventEmitter` 设置的 `emitter.setMaxListeners(n)` 的当前最大侦听器值，或默认值为 <xref:EventEmitter.defaultMaxListeners>。
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	返回当前设定的最大听众数量。对于 `EventEmitter`s，这的行为与调用 `.getMaxListeners` 发射极完全相同。对于 `EventTarget`s，这是获得事件目标最大事件监听者的唯一方法。如果单个事件目标的事件处理程序数量超过最大集合，事件目标会打印警告。 `import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); console.log(getMaxListeners(ee)); // 10 setMaxListeners(11, ee); console.log(getMaxListeners(ee)); // 11 } { const et = new EventTarget(); console.log(getMaxListeners(et)); // 10 setMaxListeners(11, et); console.log(getMaxListeners(et)); // 11 }`
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string \| symbol)	一种类方法返回在给定 `eventNameemitter`上注册的监听者数量。 `import { EventEmitter, listenerCount } from 'node:events'; const myEmitter = new EventEmitter(); myEmitter.on('event', () => {}); myEmitter.on('event', () => {}); console.log(listenerCount(myEmitter, 'event')); // Prints: 2`
listenerCount<K>(string \| symbol, Function)	返回侦听名为 `eventName`的事件的侦听器数。如果提供了 `listener`，它将返回在事件的侦听器列表中找到的侦听器的次数。
listeners<K>(string \| symbol)	返回名为 `eventName`的事件的侦听器数组的副本。 `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
off<K>(string \| symbol, (args: any[]) => void)	`emitter.removeListener()`的别名。
on(EventEmitter<DefaultEventMap>, string \| symbol, StaticEventEmitterIteratorOptions)	`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` 事件。如果发射`EventEmitter'error'`，它会抛出。退出循环时会移除所有监听者。每次迭代返回的数 `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()); 使用 `close` 选项指定一组事件名称，结束迭代： `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); ee.emit('close'); }); for await (const event of on(ee, 'foo', { close: ['close'] })) { console.log(event); // prints ['bar'] [42] } // the loop will exit after 'close' is emitted console.log('done'); // prints 'done'`
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string \| symbol, (args: any[]) => void)	将 `listener` 函数添加到名为 `eventName`的事件的侦听器数组的末尾。不会进行检查，以查看是否已添加 `listener`。传递 `eventName` 和 `listener` 相同组合的多个调用将导致添加 `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`
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); }` 事件的特殊处理 `'error'` 仅在等待下一个事件时使用 `events.once()` 。如果 `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!
once(EventTarget, string, StaticEventEmitterOptions)
once<K>(string \| symbol, (args: any[]) => void)	为名为的事件添加 `listenereventName` 函数。下次触发 `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`
open()
open(Callback<Connected>)
prependListener<K>(string \| symbol, (args: any[]) => void)	将函数添加到名为的事件的侦听器数组的开始。不会进行检查，以查看是否已添加 `listener`。传递 `eventName` 和 `listener` 相同组合的多个调用将导致添加 `listener` 并多次调用。 `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` 返回对 `EventEmitter`的引用，以便可以链接调用。
prependOnceListener<K>(string \| symbol, (args: any[]) => void)	将名为的事件一次性函数添加到侦听器数组开始。下次触发 `eventName` 时，将删除此侦听器，然后调用。 `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` 返回对 `EventEmitter`的引用，以便可以链接调用。
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');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string \| symbol)	删除所有侦听器或指定 `eventName`的侦听器。删除代码中的其他位置添加的侦听器是错误的做法，尤其是在由其他组件或模块（例如套接字或文件流）创建 `EventEmitter` 实例时。返回对 `EventEmitter`的引用，以便可以链接调用。
removeListener<K>(string \| symbol, (args: any[]) => void)	从名为 `listener`的事件的侦听器数组中删除指定的 `eventName`。 `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` 最多会从侦听器数组中删除侦听器的一个实例。如果为指定的 `eventName`向侦听器数组添加了多次单个侦听器，则必须多次调用 `removeListener()` 才能删除每个实例。发出事件后，在发出时附加到该事件的所有侦听器将按顺序调用。这意味着在发出和之后，任何或调用，最后一个侦听器完成执行不会将其从正在进行的中删除。后续事件的行为与预期相同。 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`的引用，以便可以链接调用。
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	默认情况下，如果为特定事件添加了多个 `EventEmitter` 侦听器，`10`将打印警告。这是一个有用的默认值，可帮助查找内存泄漏。 `emitter.setMaxListeners()` 方法允许修改此特定 `EventEmitter` 实例的限制。该值可以设置为 `Infinity`（或 `0`），以指示无限数量的侦听器。返回对 `EventEmitter`的引用，以便可以链接调用。
setMaxListeners(number, (EventEmitter<DefaultEventMap> \| EventTarget)[])	`import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);`
setRetryPolicy(RetryPolicy)	设置客户端在所有操作上使用的重试策略。默认值为 ExponentialBackoffWithJitter。
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

captureRejections

值：布尔

更改所有新EventEmitter对象的默认captureRejections选项。

static captureRejections: boolean

属性值

boolean

继承自 内部客户端。捕获拒绝

captureRejectionSymbol

值：Symbol.for('nodejs.rejection')

看看如何编写自定义 rejection handler文档。

static captureRejectionSymbol: typeof captureRejectionSymbol

属性值

typeof captureRejectionSymbol

继承自 内部客户端。捕获拒绝符号

defaultMaxListeners

默认情况下，单个活动最多只能注册听 10 众人数。使用该emitter.setMaxListeners(n)方法可以针对单个EventEmitter实例更改该限制。要更改所有EventEmitter 实例的默认值，可以使用该 events.defaultMaxListeners 属性。如果该值不是正数，则抛出a 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

继承自 InternalClient.defaultMaxListeners

errorMonitor

该符号用于安装仅用于监控 'error' 事件的监听器。使用该符号安装的监听器会在常规 'error' 监听器被调用之前被调用。

使用该符号安装监听器不会改变事件一旦 'error' 发出的行为。因此，如果没有安装常规 'error' 监听器，进程仍然会崩溃。

static errorMonitor: typeof errorMonitor

属性值

typeof errorMonitor

继承自 InternalClient.errorMonitor

close()

function close(): Promise<Disconnected>

返回

Promise<Disconnected>

close(Callback<Disconnected>)

关闭传输连接并销毁客户端资源。

注意：调用此方法后，无法重复使用 ModuleClient 对象。

function close(closeCallback?: Callback<Disconnected>)

参数

closeCallback: Callback<Disconnected>

在传输断开连接且客户端关闭后，要调用的可选函数。

fromAuthenticationProvider(AuthenticationProvider, any)

从给定的身份验证方法并使用给定的传输类型创建 IoT 中心模块客户端。

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): ModuleClient

参数

authenticationProvider: AuthenticationProvider

用于获取 IoT 中心的身份验证参数的对象。

transportCtor: any

用于连接到 IoT 中心的传输协议。

返回

ModuleClient

fromConnectionString(string, any)

使用给定的传输类型从给定连接字符串创建 IoT 中心设备客户端。

static function fromConnectionString(connStr: string, transportCtor: any): ModuleClient

参数

connStr: string

封装 IoT 中心的“设备连接”权限的连接字符串。

transportCtor: any

传输构造函数。

返回

ModuleClient

fromEnvironment(any)

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

参数

transportCtor: any

返回

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

使用环境中的配置信息创建 IoT 中心模块客户端。

如果存在名为 EdgeHubConnectionString 或 IotHubConnectionString 的环境变量，则使用该值，行为与调用传入 fromConnectionString 相同。如果这些环境变量不存在，则必须定义以下变量：

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

参数

transportCtor: any

用于连接到 IoT 中心的传输协议。

callback: Callback<ModuleClient>

在构造 ModuleClient 时或创建客户端时发生错误时调用的可选回调。

fromSharedAccessSignature(string, any)

使用给定的传输类型从给定的共享访问签名创建 IoT 中心模块客户端。

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

参数

sharedAccessSignature: string

一个共享访问签名，用于封装 IoT 中心的“设备连接”权限。

transportCtor: any

返回

ModuleClient

invokeMethod(string, MethodParams)

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

参数

deviceId: string

methodParams: MethodParams

返回

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

在同一 IoTEdge 设备上调用下游设备或另一个模块上的方法。请注意，仅当模块作为 IoTEdge 设备的一部分运行时，此功能才有效。

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

参数

deviceId: string

目标设备标识符

methodParams: MethodParams

直接方法调用的参数

callback: Callback<MethodResult>

将使用 Error 对象或方法调用结果调用的可选回调。

invokeMethod(string, string, MethodParams)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

参数

deviceId: string

moduleId: string

methodParams: MethodParams

返回

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

参数

deviceId: string

moduleId: string

methodParams: MethodParams

callback: Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

为名为 methodName的方法注册回调。

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

参数

methodName: string

将由回调处理的方法的名称

callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

每当收到调用 methodName 的方法的方法请求时，应调用的函数。

sendOutputEvent(string, Message)

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

参数

outputName: string

message: Message

返回

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

将事件发送到给定模块输出

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

参数

outputName: string

要向其发送事件的输出的名称

message: Message

要发送到给定输出的消息

callback: Callback<MessageEnqueued>

在操作已排队时要调用的可选函数。

sendOutputEventBatch(string, Message[])

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

参数

outputName: string

messages: Message[]

返回

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

将事件数组发送到给定的模块输出

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

参数

outputName: string

要向其发送事件的输出的名称

messages: Message[]

callback: Callback<MessageEnqueued>

在操作已排队时调用的函数。

setOptions(DeviceClientOptions)

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

参数

options: DeviceClientOptions

返回

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

将选项传递给可用于配置传输的 ModuleClient 对象。

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

参数

options: DeviceClientOptions

DeviceClientOptions 对象。

done: Callback<TransportConfigured>

设置选项后要调用的可选回调。

abandon(Message)

function abandon(message: Message): Promise<MessageAbandoned>

参数

message: Message

返回

Promise<MessageAbandoned>

继承自 InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>)

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

参数

message: Message

abandonCallback: Callback<MessageAbandoned>

继承自 InternalClient.abandon

addAbortListener(AbortSignal, (event: Event) => void)

在提供的signal网站上收听一次abort活动。

在中止信号上监听 abort 事件是不安全的，可能导致资源泄漏，因为其他第三方可能呼叫 e.stopImmediatePropagation()。很遗憾，Node.js 无法更改这一点，因为这会违反网络标准。此外，原始API让人很容易忘记移除监听器。

该 API 通过监听stopImmediatePropagation事件且不阻止监听者运行，从而安全地在 Node.js API 中使用 AbortSignals。

退回一次性产品，以便更容易取消订阅。

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

继承自 InternalClient.addAbortListener

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

emitter.on(eventName, listener)的别名。

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

参数

eventName: string | symbol

listener: (args: any[]) => void

返回

ModuleClient

继承自 InternalClient.addListener

complete(Message)

function complete(message: Message): Promise<MessageCompleted>

参数

message: Message

返回

Promise<MessageCompleted>

继承自 InternalClient.complete

complete(Message, Callback<MessageCompleted>)

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

参数

message: Message

completeCallback: Callback<MessageCompleted>

继承自 InternalClient.complete

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

继承自 InternalClient.emit

eventNames()

返回一个数组，其中列出发出器已注册侦听器的事件。数组中的值为字符串或 Symbols。

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

返回

(string | symbol)[]

继承自 internalClient.eventNames

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

返回名为 eventName的事件的侦听器数组的副本。

对于 EventEmitters，这的行为与调用 .listeners 发射极完全相同。

对于 EventTargets，这是获得事件目标事件监听者的唯一方法。这对调试和诊断非常有用。

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

继承自 InternalClient.getEventListeners

getMaxListeners()

返回由 EventEmitter 设置的 emitter.setMaxListeners(n) 的当前最大侦听器值，或默认值为 <xref:EventEmitter.defaultMaxListeners>。

function getMaxListeners(): number

返回

number

继承自 InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

返回当前设定的最大听众数量。

对于 EventEmitters，这的行为与调用 .getMaxListeners 发射极完全相同。

对于 EventTargets，这是获得事件目标最大事件监听者的唯一方法。如果单个事件目标的事件处理程序数量超过最大集合，事件目标会打印警告。

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

继承自 InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

返回

Promise<Twin>

继承自 InternalClient.getTwin

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

参数

done: Callback<Twin>

继承自 InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

警告

现已弃用此 API。

Since v3.2.0 - Use listenerCount instead.

一种类方法返回在给定 eventNameemitter上注册的监听者数量。

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

继承自 InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

返回侦听名为 eventName的事件的侦听器数。如果提供了 listener，它将返回在事件的侦听器列表中找到的侦听器的次数。

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

参数

eventName: string | symbol

正在侦听的事件的名称

listener: Function

事件处理程序函数

返回

number

继承自 InternalClient.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[]

继承自 InternalClient.listeners

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

emitter.removeListener()的别名。

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

参数

eventName: string | symbol

listener: (args: any[]) => void

返回

ModuleClient

继承自 InternalClient.off

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

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 事件。如果发射EventEmitter'error'，它会抛出。退出循环时会移除所有监听者。每次迭代返回的数 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());

使用 close 选项指定一组事件名称，结束迭代：

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);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

参数

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterIteratorOptions

返回

AsyncIterator<any[], any, any>

一个 AsyncIterator 迭 eventName 代由 emitter

继承自 InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions)

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

参数

emitter: EventTarget

eventName: string

options: StaticEventEmitterIteratorOptions

返回

AsyncIterator<any[], any, any>

继承自 InternalClient.on

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

将 listener 函数添加到名为 eventName的事件的侦听器数组的末尾。不会进行检查，以查看是否已添加 listener。传递 eventName 和 listener 相同组合的多个调用将导致添加 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): ModuleClient

参数

eventName: string | symbol

事件的名称。

listener: (args: any[]) => void

回调函数

返回

ModuleClient

继承自 InternalClient.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);
}

事件的特殊处理 'error' 仅在等待下一个事件时使用 events.once() 。如果 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[]>

继承自 InternalClient.once

once(EventTarget, string, StaticEventEmitterOptions)

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

参数

emitter: EventTarget

eventName: string

options: StaticEventEmitterOptions

返回

Promise<any[]>

继承自 InternalClient.once

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

为名为的事件添加 listenereventName 函数。下次触发 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): ModuleClient

参数

eventName: string | symbol

事件的名称。

listener: (args: any[]) => void

回调函数

返回

ModuleClient

继承自 InternalClient.once

open()

function open(): Promise<Connected>

返回

Promise<Connected>

继承自 InternalClient.open

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

参数

openCallback: Callback<Connected>

继承自 InternalClient.open

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

将函数添加到名为的事件的侦听器数组的开始。不会进行检查，以查看是否已添加 listener。传递 eventName 和 listener 相同组合的多个调用将导致添加 listener 并多次调用。

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

返回对 EventEmitter的引用，以便可以链接调用。

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

参数

eventName: string | symbol

事件的名称。

listener: (args: any[]) => void

回调函数

返回

ModuleClient

继承自 InternalClient.prependListener

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

将名为的事件一次性函数添加到侦听器数组开始。下次触发 eventName 时，将删除此侦听器，然后调用。

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

返回对 EventEmitter的引用，以便可以链接调用。

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

参数

eventName: string | symbol

事件的名称。

listener: (args: any[]) => void

回调函数

返回

ModuleClient

继承自 InternalClient.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[]

继承自 InternalClient.rawListeners

reject(Message)

function reject(message: Message): Promise<MessageRejected>

参数

message: Message

返回

Promise<MessageRejected>

继承自 InternalClient.reject

reject(Message, Callback<MessageRejected>)

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

参数

message: Message

rejectCallback: Callback<MessageRejected>

继承自 InternalClient.reject

removeAllListeners(string | symbol)

删除所有侦听器或指定 eventName的侦听器。

删除代码中的其他位置添加的侦听器是错误的做法，尤其是在由其他组件或模块（例如套接字或文件流）创建 EventEmitter 实例时。

返回对 EventEmitter的引用，以便可以链接调用。

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

参数

eventName: string | symbol

返回

ModuleClient

继承自 InternalClient.removeAllListeners

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

从名为 listener的事件的侦听器数组中删除指定的 eventName。

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

removeListener() 最多会从侦听器数组中删除侦听器的一个实例。如果为指定的 eventName向侦听器数组添加了多次单个侦听器，则必须多次调用 removeListener() 才能删除每个实例。

发出事件后，在发出时附加到该事件的所有侦听器将按顺序调用。这意味着在发出和之后，任何或调用，最后一个侦听器完成执行不会将其从正在进行的中删除。后续事件的行为与预期相同。

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

参数

eventName: string | symbol

listener: (args: any[]) => void

返回

ModuleClient

继承自 InternalClient.removeListener

sendEvent(Message)

function sendEvent(message: Message): Promise<MessageEnqueued>

参数

message: Message

返回

Promise<MessageEnqueued>

继承自 InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>)

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

参数

message: Message

sendEventCallback: Callback<MessageEnqueued>

继承自 InternalClient.sendEvent

sendEventBatch(Message[])

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

参数

messages: Message[]

返回

Promise<MessageEnqueued>

继承自 InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>)

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

参数

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

继承自 InternalClient.sendEventBatch

setMaxListeners(number)

默认情况下，如果为特定事件添加了多个 EventEmitter 侦听器，10将打印警告。这是一个有用的默认值，可帮助查找内存泄漏。 emitter.setMaxListeners() 方法允许修改此特定 EventEmitter 实例的限制。该值可以设置为 Infinity（或 0），以指示无限数量的侦听器。

返回对 EventEmitter的引用，以便可以链接调用。

function setMaxListeners(n: number): ModuleClient

参数

n: number

返回

ModuleClient

继承自 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)[])

参数

n: number

一个非负数。每 EventTarget 场活动的最大听众人数。

eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[]

零个或多个{EventTarget}或{EventEmitter}实例。如果没有指定 n ，则将设置为所有新创建的 {EventTarget} 和 {EventEmitter} 对象的默认最大值。

继承自 InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

设置客户端在所有操作上使用的重试策略。默认值为 ExponentialBackoffWithJitter。

function setRetryPolicy(policy: RetryPolicy)

参数

policy: RetryPolicy

{RetryPolicy}应用于所有未来操作的重试策略。

继承自 InternalClient.setRetryPolicy

setTransportOptions(any)

function setTransportOptions(options: any): Promise<TransportConfigured>

参数

options: any

返回

Promise<TransportConfigured>

继承自 InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>)

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

参数

options: any

done: Callback<TransportConfigured>

继承自 InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

参数

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

继承自 InternalClient.updateSharedAccessSignature

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

参数

error: Error

event: string | symbol

args: AnyRest

继承自 InternalClient.__@captureRejectionSymbol@141

ModuleClient class

继承属性

方法

继承的方法

继承属性详细信息

captureRejections

属性值

captureRejectionSymbol

属性值

defaultMaxListeners

属性值

errorMonitor

属性值

方法详细信息

close()

返回

close(Callback<Disconnected>)

参数

fromAuthenticationProvider(AuthenticationProvider, any)

参数

返回

fromConnectionString(string, any)

参数

返回

fromEnvironment(any)

参数

返回

fromEnvironment(any, Callback<ModuleClient>)

参数

fromSharedAccessSignature(string, any)

参数

返回

invokeMethod(string, MethodParams)

参数

返回

invokeMethod(string, MethodParams, Callback<MethodResult>)

参数

invokeMethod(string, string, MethodParams)

参数

返回

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

参数

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

参数

sendOutputEvent(string, Message)

参数

返回

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

参数

sendOutputEventBatch(string, Message[])

参数

返回

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

参数

setOptions(DeviceClientOptions)

参数

返回

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

参数

继承的方法详细信息

abandon(Message)

参数

返回

abandon(Message, Callback<MessageAbandoned>)

参数

addAbortListener(AbortSignal, (event: Event) => void)

参数

返回

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

参数

返回

complete(Message)

参数

返回

complete(Message, Callback<MessageCompleted>)

参数

emit<K>(string | symbol, AnyRest)

参数

返回

eventNames()