你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

ModuleClient class

  • 参考
包:
azure-iot-device

IoT 中心设备客户端，用于将设备与 Azure IoT 中心连接。

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

Extends

InternalClient

继承属性

captureRejections

值： 布尔值

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

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

了解如何编写自定义 rejection handler。
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'。
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 无法更改此设置，因为它会违反 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]();
  }
}
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()

返回一个数组，其中列出了发射器为其注册了侦听器的事件。 数组中的值为字符串或 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) ]
getEventListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget, 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] ]
}
getMaxListeners()

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

返回当前设置的最大侦听器数。

对于 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
}
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

一个类方法，该方法返回在给定 上注册的给定 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
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, 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());
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
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!
once(_DOMEventTarget, string, StaticEventEmitterOptions)
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
open()
open(Callback<Connected>)
prependListener<K>(string | symbol, (args: any[]) => void)

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

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

返回对 的 EventEmitter引用，以便可以链接调用。
prependOnceListener<K>(string | symbol, (args: any[]) => void)

将名为 eventName 的事件的一次性listener函数添加到侦听器数组的开头。 下次触发时 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)

从名为 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引用，以便可以链接调用。
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> | _DOMEventTarget)[]) 
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

继承自 InternalClient.captureRejections

captureRejectionSymbol

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

了解如何编写自定义 rejection handler。

static captureRejectionSymbol: typeof captureRejectionSymbol

属性值

typeof captureRejectionSymbol

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

继承自 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 无法更改此设置，因为它会违反 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 一次性对象。

继承自 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> | _DOMEventTarget, 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> | _DOMEventTarget, name: string | symbol): Function[]

参数

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

name

string | symbol

返回

Function[]

继承自 InternalClient.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

返回

number

继承自 InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

返回当前设置的最大侦听器数。

对于 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> | _DOMEventTarget): number

参数

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

返回

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.

一个类方法，该方法返回在给定 上注册的给定 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

继承自 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, 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

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

仅当 用于等待另一个事件时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[]>

继承自 InternalClient.once

once(_DOMEventTarget, string, StaticEventEmitterOptions) 

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

参数

emitter

_DOMEventTarget

eventName

string

options

StaticEventEmitterOptions

返回

Promise<any[]>

继承自 InternalClient.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): 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 的相同组合的eventName多个调用将导致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 的事件的一次性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): 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)

从名为 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): 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> | _DOMEventTarget)[]) 

import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | _DOMEventTarget)[])

参数

n

number

非负数。 每个 EventTarget 事件的最大侦听器数。

eventTargets

(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]

继承自 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@138