ModuleClient class

function close(): Promise<Disconnected>

返回

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

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

function close(closeCallback?: Callback<Disconnected>)

参数

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

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

参数

返回

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

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

参数

返回

static function fromEnvironment(transportCtor: any): Promise<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>)

参数

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

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

参数

返回

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

参数

返回

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

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

参数

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

参数

返回

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

参数

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

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

参数

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

参数

返回

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

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

参数

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

参数

返回

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

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

参数

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

参数

返回

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

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

参数

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

参数

返回

继承自 InternalClient.abandon

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

参数

继承自 InternalClient.abandon

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

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

参数

返回

继承自 InternalClient.addListener

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

参数

返回

继承自 InternalClient.complete

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

参数

继承自 InternalClient.complete

同步调用为名为 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<E>(eventName: string | symbol, args: any[]): boolean

参数

返回

继承自 InternalClient.emit

返回一个数组，其中列出发出器已注册侦听器的事件。

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

返回

继承自 internalClient.eventNames

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

function getMaxListeners(): number

返回

继承自 InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

返回

继承自 InternalClient.getTwin

function getTwin(done: Callback<Twin>)

参数

继承自 InternalClient.getTwin

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

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

参数

返回

继承自 InternalClient.listenerCount

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

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<E>(eventName: string | symbol): (args: any[]) => void[]

参数

返回

继承自 InternalClient.listeners

emitter.removeListener()的别名。

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

参数

返回

继承自 InternalClient.off

将 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<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

参数

返回

继承自 InternalClient.on

为名为 的事件添加 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<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

参数

返回

继承自 InternalClient.once

function open(): Promise<Connected>

返回

继承自 InternalClient.open

function open(openCallback: Callback<Connected>)

参数

继承自 InternalClient.open

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

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

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

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

参数

返回

继承自 InternalClient.prependListener

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

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

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

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

参数

返回

继承自 InternalClient.prependOnceListener

返回名为 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<E>(eventName: string | symbol): (args: any[]) => void[]

参数

返回

继承自 InternalClient.rawListeners

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

参数

返回

继承自 InternalClient.reject

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

参数

继承自 InternalClient.reject

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

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

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

function removeAllListeners<E>(eventName?: string | symbol): ModuleClient

参数

返回

继承自 InternalClient.removeAllListeners

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

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<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

参数

返回

继承自 InternalClient.removeListener

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

参数

返回

继承自 InternalClient.sendEvent

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

参数

继承自 InternalClient.sendEvent

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

参数

返回

继承自 InternalClient.sendEventBatch

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

参数

继承自 InternalClient.sendEventBatch

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

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

function setMaxListeners(n: number): ModuleClient

参数

返回

继承自 InternalClient.setMaxListeners

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

function setRetryPolicy(policy: RetryPolicy)

参数

继承自 InternalClient.setRetryPolicy

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

参数

返回

继承自 InternalClient.setTransportOptions

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

参数

继承自 InternalClient.setTransportOptions

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

参数

继承自 InternalClient.updateSharedAccessSignature

Symbol.for('nodejs.rejection')该方法用于在发射事件时发生承诺拒绝，并且captureRejections在发射端被启用时调用。 可以用 events.captureRejectionSymbol 代替 Symbol.for('nodejs.rejection')。

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

参数

继承自 InternalClient.__@captureRejectionSymbol@127