Client class

値: ブール

すべての新しい captureRejections オブジェクトの既定の EventEmitter オプションを変更します。

static captureRejections: boolean

プロパティ値

EventEmitter.captureRejections から継承された

値: Symbol.for('nodejs.rejection')

カスタム rejection handlerを記述する方法を参照してください。

static captureRejectionSymbol: typeof captureRejectionSymbol

プロパティ値

EventEmitter.captureRejectionSymbol から継承された

既定では、任意の 1 つのイベントに対して最大 10 リスナーを登録できます。 この制限は、EventEmitter メソッドを使用して個々の emitter.setMaxListeners(n) インスタンスに対して変更できます。 すべての インスタンス 既定値を変更するには、 プロパティを使用できます。 この値が正の数でない場合は、RangeError がスローされます。

変更は、変更前に作成されたものも含め、すべての インスタンス 影響するため、 を設定するときは注意してください。 ただし、emitter.setMaxListeners(n) の呼び出しは引き続き events.defaultMaxListenersよりも優先されます。

これはハード制限ではありません。 EventEmitter インスタンスでは、より多くのリスナーを追加できますが、"EventEmitter メモリ リークの可能性" が検出されたことを示すトレース警告が stderr に出力されます。 単一の 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

プロパティ値

EventEmitter.defaultMaxListeners から継承された

このシンボルは、'error' イベントのみを監視するためのリスナーをインストールするために使用されます。 このシンボルを使用してインストールされたリスナーは、通常の 'error' リスナーが呼び出される前に呼び出されます。

このシンボルを使用してリスナーをインストールしても、'error' イベントが生成された後の動作は変更されません。 そのため、通常の 'error' リスナーがインストールされていない場合でも、プロセスはクラッシュします。

static errorMonitor: typeof errorMonitor

プロパティ値

EventEmitter.errorMonitor から継承された

function close(): Promise<ResultWithIncomingMessage<Disconnected>>

戻り値

IoT ハブへの接続を閉じます。

function close(done?: IncomingMessageCallback<Disconnected>)

パラメーター

既定のトランスポート (Amqp) または 2 番目の引数で指定されたものを使用して、指定された接続文字列から IoT Hub サービス クライアントを作成します。

static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client

パラメーター

戻り値

既定のトランスポート (Amqp) または 2 番目の引数で指定されたものを使用して、指定された共有アクセス署名から IoT Hub サービス クライアントを作成します。

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client

パラメーター

戻り値

既定のトランスポート (Amqp) または 2 番目の引数で指定されたものを使用して、指定された Azure tokenCredential から IoT Hub サービス クライアントを作成します。

static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client

パラメーター

戻り値

function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

戻り値

クライアントが新しいフィードバック メッセージを受信したときにイベントを出力する AmqpReceiver オブジェクトを返します。

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

パラメーター

function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

戻り値

クライアントが新しいファイル アップロード通知を受信したときにイベントを出力する AmqpReceiver オブジェクトを返します。

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

パラメーター

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

パラメーター

戻り値

特定のデバイスまたはモジュールでメソッドを呼び出します。

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)

パラメーター

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

パラメーター

戻り値

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)

パラメーター

function open(): Promise<ResultWithIncomingMessage<Connected>>

戻り値

IoT ハブへの接続を開きます。

function open(done?: IncomingMessageCallback<Connected>)

パラメーター

function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>

パラメーター

戻り値

デバイスにメッセージを送信します。

function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)

パラメーター

クライアントがネットワーク操作を再試行するために使用するポリシーを設定します。

function setRetryPolicy(policy: RetryPolicy)

パラメーター

指定された abortの signal イベントを 1 回リッスンします。

中止信号で abort イベントをリッスンすることは安全ではなく、信号を持つ別のサードパーティが e.stopImmediatePropagation()を呼び出すことができるため、リソースリークにつながる可能性があります。 残念ながら、Node.js は Web 標準に違反するため、これを変更できません。 また、元の API を使用すると、リスナーの削除を忘れやすくなります。

この API では、AbortSignal がリスナーの実行を妨げるようなイベントをリッスンすることで、これらの 2 つの問題を解決することで、Node.js API で 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 リスナーを削除する破棄可能。

EventEmitter.addAbortListener から継承された

emitter.on(eventName, listener)のエイリアス。

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

パラメーター

戻り値

eventEmitter.addListener から継承

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

パラメーター

戻り値

eventEmitter.emit から継承

エミッターがリスナーを登録したイベントを一覧表示する配列を返します。 配列内の値は文字列または Symbolです。

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

戻り値

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

パラメーター

戻り値

EventEmitter.getEventListeners から継承された

EventEmitter の現在の最大リスナー値を返します。この値は、emitter.setMaxListeners(n) によって設定されるか、既定で <xref:EventEmitter.defaultMaxListeners>に設定されます。

function getMaxListeners(): number

戻り値

EventEmitter.getMaxListeners から継承された

現在設定されているリスナーの最大量を返します。

EventEmitterの場合、これはエミッターでの .getMaxListeners の呼び出しとまったく同じように動作します。

EventTargetの場合、これはイベント ターゲットの最大イベント リスナーを取得する唯一の方法です。 1 つの 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

パラメーター

戻り値

EventEmitter.getMaxListeners から継承された

指定した 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

パラメーター

戻り値

eventEmitter.listenerCount から継承

eventNameという名前のイベントをリッスンしているリスナーの数を返します。 listener 指定すると、イベントのリスナーの一覧でリスナーが見つかった回数が返されます。

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

パラメーター

戻り値

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

パラメーター

戻り値

EventEmitter.listeners から継承された

emitter.removeListener()のエイリアス。

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

パラメーター

戻り値

EventEmitter.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

イベントを反復処理する AsyncIteratoreventName 返します。 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[], undefined, any>

パラメーター

戻り値

AsyncIterator によって生成 eventName イベントを反復処理する emitter

EventEmitter.on から継承された

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

パラメーター

戻り値

EventEmitter.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

パラメーター

戻り値

EventEmitter.on から継承された

Promise が特定のイベントを生成したときに満たされる EventEmitter を作成します。または、EventEmitter が待機中に 'error' を出力した場合に拒否されます。 Promise は、指定されたイベントに出力されるすべての引数の配列で解決されます。

このメソッドは意図的に汎用であり、EventTarget インターフェイス Web プラットフォームで動作します。これは、特別な イベント セマンティクスがなく、 イベントをリッスンしません。

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

パラメーター

戻り値

EventEmitter.once から継承された

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

パラメーター

戻り値

EventEmitter.once から継承された

という名前のイベント 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): Client

パラメーター

戻り値

EventEmitter.once から継承された

関数を、という名前のイベントのリスナー配列の先頭 に追加します。 listener が既に追加されているかどうかを確認するチェックは行われません。 eventName と listener の同じ組み合わせを渡す複数の呼び出しでは、listener が複数回追加され、呼び出されます。

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

呼び出しをチェーンできるように、EventEmitterへの参照を返します。

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

パラメーター

戻り値

EventEmitter.prependListener から継承された

という名前のイベントの 1 回限りの 関数をリスナー配列の先頭 に追加します。 次に 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

パラメーター

戻り値

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

パラメーター

戻り値

EventEmitter.rawListeners から継承された

すべてのリスナー、または指定した eventNameのリスナーを削除します。

特に、EventEmitter インスタンスが他のコンポーネントまたはモジュール (ソケットやファイル ストリームなど) によって作成された場合に、コード内の他の場所に追加されたリスナーを削除するのは不適切な方法です。

呼び出しをチェーンできるように、EventEmitterへの参照を返します。

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

パラメーター

戻り値

EventEmitter.removeAllListeners から継承された

listenerという名前のイベントのリスナー配列から、指定した eventName を削除します。

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

removeListener() は、リスナー配列からリスナーのインスタンスを最大で 1 つ削除します。 指定した eventNameのリスナー配列に 1 つのリスナーが複数回追加されている場合は、各インスタンスを削除するために 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() メソッドによって返されるリスナー配列のコピーを再作成する必要があることを意味します。

(次の例のように) 1 つのイベントに対して 1 つの関数がハンドラーとして複数回追加された場合、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

パラメーター

戻り値

EventEmitter.removeListener から継承された

既定では、EventEmitters は、特定のイベントに対して 10 を超えるリスナーが追加された場合に警告を出力します。 これは、メモリ リークの検出に役立つ便利な既定値です。 emitter.setMaxListeners() メソッドを使用すると、この特定の EventEmitter インスタンスの制限を変更できます。 この値を Infinity (または 0) に設定すると、リスナーの数に制限はありません。

呼び出しをチェーンできるように、EventEmitterへの参照を返します。

function setMaxListeners(n: number): Client

パラメーター

戻り値

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

パラメーター

EventEmitter.setMaxListeners から継承された

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

パラメーター

継承元 EventEmitter.__@captureRejectionSymbol@116