Client class

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

参数

值：布尔

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

static captureRejections: boolean

属性值

继承自 InternalClient.captureRejections

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

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

static captureRejectionSymbol: typeof captureRejectionSymbol

属性值

继承自 InternalClient.captureRejectionSymbol

默认情况下，可以为任何单个事件注册最多 10 侦听器。 可以使用 emitter.setMaxListeners(n) 方法更改单个 EventEmitter 实例的此限制。 若要更改 所有EventEmitter 实例的默认值，可以使用 events.defaultMaxListeners 属性。 如果此值不是正数，则会引发 RangeError。

设置 events.defaultMaxListeners 时请小心，因为更改会影响 所有EventEmitter 实例，包括更改之前创建的实例。 但是，调用 emitter.setMaxListeners(n) 仍优先于 events.defaultMaxListeners。

这不是硬性限制。 EventEmitter 实例将允许添加更多侦听器，但会输出跟踪警告，以指示检测到“可能的 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

属性值

继承自 InternalClient.defaultMaxListeners

此符号应用于安装仅监视 'error' 事件的侦听器。 在调用常规 'error' 侦听器之前调用使用此符号安装的侦听器。

发出 'error' 事件后，使用此符号安装侦听器不会更改行为。 因此，如果未安装任何常规 'error' 侦听器，该过程仍将崩溃。

static errorMonitor: typeof errorMonitor

属性值

继承自 InternalClient.errorMonitor

function close(): Promise<Disconnected>

返回

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

注意：调用此方法后，不能重复使用 Client 对象。

function close(closeCallback?: Callback<Disconnected>)

参数

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

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

参数

返回

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

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

参数

返回

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

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

参数

返回

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

参数

返回

getBlobSharedAccessSignature 从 IoT 中心获取链接的存储帐户 SAS 令牌

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

参数

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

参数

返回

notifyBlobUploadStatus 方法将 IoT 中心发送 Blob 上传的结果。

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

参数

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

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

参数

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

参数

返回

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

参数

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

参数

返回

uploadToBlob 方法将流上传到 blob。

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

参数

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

参数

返回

继承自 InternalClient.abandon

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

参数

继承自 InternalClient.abandon

在提供的 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

参数

返回

一次性删除 abort 侦听器。

继承自 InternalClient.addAbortListener

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

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

参数

返回

继承自 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<K>(eventName: string | symbol, args: AnyRest): boolean

参数

返回

继承自 InternalClient.emit

返回一个数组，其中列出发出器已注册侦听器的事件。 数组中的值为字符串或 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)[]

返回

继承自 internalClient.eventNames

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

对于 EventEmitter，这与在发射器上调用 .listeners 的行为完全相同。

对于 EventTarget，这是获取事件目标的事件侦听器的唯一方法。 这对于调试和诊断目的非常有用。

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

参数

返回

继承自 InternalClient.getEventListeners

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

function getMaxListeners(): number

返回

继承自 InternalClient.getMaxListeners

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

对于 EventEmitter，这与在发射器上调用 .getMaxListeners 的行为完全相同。

对于 EventTarget，这是获取事件目标的最大事件侦听器的唯一方法。 如果单个 EventTarget 上的事件处理程序数超过最大集，EventTarget 将输出警告。

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

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

参数

返回

继承自 InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

返回

继承自 InternalClient.getTwin

function getTwin(done: Callback<Twin>)

参数

继承自 InternalClient.getTwin

一个类方法，返回在给定 emitter上注册的给定 eventName 的侦听器数。

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

参数

返回

继承自 InternalClient.listenerCount

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

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

参数

返回

继承自 InternalClient.listenerCount

返回名为 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[]

参数

返回

继承自 InternalClient.listeners

emitter.removeListener()的别名。

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

参数

返回

继承自 InternalClient.off

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

返回循环访问 eventName 事件的 AsyncIterator。 如果 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): AsyncIterableIterator<any[]>

参数

返回

循环访问 emitter 发出的 eventName 事件的 AsyncIterator

继承自 InternalClient.on

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

参数

返回

继承自 InternalClient.on

将 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): Client

参数

返回

继承自 InternalClient.on

创建在 EventEmitter 发出给定事件时或当 EventEmitter 在等待时发出 'error' 时被拒绝的 Promise。 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[]>

参数

返回

继承自 InternalClient.once

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

参数

返回

继承自 InternalClient.once

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

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

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

默认情况下，以添加事件侦听器的顺序调用事件侦听器。 emitter.prependOnceListener() 方法可用作将事件侦听器添加到侦听器数组开头的替代方法。

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

参数

返回

继承自 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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

参数

返回

继承自 InternalClient.prependListener

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

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

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

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

参数

返回

继承自 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<K>(eventName: string | symbol): Function[]

参数

返回

继承自 InternalClient.rawListeners

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

参数

返回

继承自 InternalClient.reject

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

参数

继承自 InternalClient.reject

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

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

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

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

参数

返回

继承自 InternalClient.removeAllListeners

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

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

参数

返回

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

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

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

function setMaxListeners(n: number): Client

参数

返回

继承自 InternalClient.setMaxListeners

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

参数

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

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

参数

继承自 InternalClient.__@captureRejectionSymbol@142 的