次の方法で共有

Twin class

  • リファレンス
パッケージ:
azure-iot-device

Device Twin は、Azure IoT ハブによって格納され、デバイスがオフラインの場合でも使用できるデバイスの状態を説明するドキュメントです。 次の 3 つのセクションを中心に構築されています。

  • タグ: サービス側からのみアクセスできるキーと値のペア
  • 必要なプロパティ: サービスによって更新され、デバイスによって受信されます
  • 報告されるプロパティ: デバイスによって更新され、サービスによって受信されます。

可能性はありますが、必要なプロパティと報告されるプロパティは一致する必要はありません。また、必要に応じて、これら 2 つのコレクションを同期するロジックが SDK のユーザーに委ねられます。

詳細については、「デバイス ツインについて」を参照してください。

Extends

EventEmitter

プロパティ

desiredPath
errorEvent
properties

必要なプロパティ ディクショナリと報告されるプロパティ ディクショナリ (それぞれ properties.desired および properties.reported)。
userRegisteredDesiredPropertiesListener

継承されたプロパティ

captureRejections

値: ブール

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

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

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

既定では、任意の 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'に設定されます。
errorMonitor

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

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

メソッド

get()
get(Callback<Twin>)

サービスからツイン全体を取得します。

継承されたメソッド

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

指定された 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]();
  }
}
addListener<K>(string | symbol, (args: any[]) => void)

emitter.on(eventName, listener)のエイリアス。
emit<K>(string | symbol, AnyRest)

eventNameという名前のイベントに登録された各リスナーを、登録された順序で同期的に呼び出し、指定された引数を各リスナーに渡します。

イベントにリスナーがある場合は true を返します。それ以外の場合 false 返します。

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
eventNames()

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

import { EventEmitter } from 'node:events';

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

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

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

eventNameという名前のイベントのリスナーの配列のコピーを返します。

EventEmitterの場合、これはエミッターでの .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()

によって設定されるか、既定値が defaultMaxListenersに設定されている の現在の最大リスナー値 返します。
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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
}
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 | symbol, StaticEventEmitterIteratorOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

イベントを反復処理する 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'
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string | symbol, (args: any[]) => void)

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

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

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

既定では、イベント リスナーは追加された順序で呼び出されます。 emitter.prependListener() メソッドは、リスナー配列の先頭にイベント リスナーを追加する代わりに使用できます。

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

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

このメソッドは意図的に汎用であり、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!
once(EventTarget, string, StaticEventEmitterOptions)
once<K>(string | symbol, (args: any[]) => void)

という名前のイベント listenereventName 関数を追加します。 次回 eventName がトリガーされると、このリスナーが削除され、呼び出されます。

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

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

既定では、イベント リスナーは追加された順序で呼び出されます。 emitter.prependOnceListener() メソッドは、リスナー配列の先頭にイベント リスナーを追加する代わりに使用できます。

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
prependListener<K>(string | symbol, (args: any[]) => void)

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

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

呼び出しをチェーンできるように、EventEmitterへの参照を返します。
prependOnceListener<K>(string | symbol, (args: any[]) => void)

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

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

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

呼び出しをチェーンできるように、EventEmitterへの参照を返します。
removeListener<K>(string | symbol, (args: any[]) => void)

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

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

removeListener() は、リスナー配列からリスナーのインスタンスを最大で 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への参照を返します。
setMaxListeners(number)

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

呼び出しをチェーンできるように、EventEmitterへの参照を返します。
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

setMaxListeners(5, target, emitter);
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

プロパティの詳細

desiredPath 

static desiredPath: string

プロパティ値

string

errorEvent 

static errorEvent: string

プロパティ値

string

properties

必要なプロパティ ディクショナリと報告されるプロパティ ディクショナリ (それぞれ properties.desired および properties.reported)。

properties: TwinProperties

プロパティ値

TwinProperties

userRegisteredDesiredPropertiesListener 

userRegisteredDesiredPropertiesListener: boolean

プロパティ値

boolean

継承されたプロパティの詳細

captureRejections

値: ブール

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

static captureRejections: boolean

プロパティ値

boolean

EventEmitter.captureRejections から継承された

captureRejectionSymbol

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

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

static captureRejectionSymbol: typeof captureRejectionSymbol

プロパティ値

typeof captureRejectionSymbol

EventEmitter.captureRejectionSymbol から継承された

defaultMaxListeners

既定では、任意の 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

プロパティ値

number

EventEmitter.defaultMaxListeners から継承された

errorMonitor

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

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

static errorMonitor: typeof errorMonitor

プロパティ値

typeof errorMonitor

EventEmitter.errorMonitor から継承された

メソッドの詳細

get() 

function get(): Promise<Twin>

戻り値

Promise<Twin>

get(Callback<Twin>)

サービスからツイン全体を取得します。

function get(callback?: Callback<Twin>)

パラメーター

callback

Callback<Twin>

省略可能な関数。ツインを使用して呼び出すか、トランスポートがツインの取得に失敗した場合はエラーになります。

継承済みメソッドの詳細

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

指定された 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

パラメーター

signal

AbortSignal

resource

(event: Event) => void

戻り値

Disposable

abort リスナーを削除する破棄可能。

EventEmitter.addAbortListener から継承された

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

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

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

パラメーター

eventName

string | symbol

listener

(args: any[]) => void

戻り値

Twin

eventEmitter.addListener から継承

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

eventEmitter.emit から継承

eventNames()

エミッターがリスナーを登録したイベントを一覧表示する配列を返します。 配列内の値は文字列または 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)[]

戻り値

(string | symbol)[]

EventEmitter.eventNames から継承された

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, 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> | EventTarget, name: string | symbol): Function[]

パラメーター

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

戻り値

Function[]

EventEmitter.getEventListeners から継承された

getMaxListeners()

によって設定されるか、既定値が defaultMaxListenersに設定されている の現在の最大リスナー値 返します。

function getMaxListeners(): number

戻り値

number

EventEmitter.getMaxListeners から継承された

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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

パラメーター

emitter

EventEmitter<DefaultEventMap> | EventTarget

戻り値

number

EventEmitter.getMaxListeners から継承された

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

eventEmitter.listenerCount から継承

listenerCount<K>(string | symbol, Function)

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

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

パラメーター

eventName

string | symbol

リッスンするイベントの名前

listener

Function

イベント ハンドラー関数

戻り値

number

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

EventEmitter.listeners から継承された

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

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

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

パラメーター

eventName

string | symbol

listener

(args: any[]) => void

戻り値

Twin

EventEmitter.off から継承された

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

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

イベントを反復処理する 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[], any, any>

パラメーター

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

戻り値

AsyncIterator<any[], any, any>

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

EventEmitter.on から継承された

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

パラメーター

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

戻り値

AsyncIterator<any[], any, any>

EventEmitter.on から継承された

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

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

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

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

既定では、イベント リスナーは追加された順序で呼び出されます。 emitter.prependListener() メソッドは、リスナー配列の先頭にイベント リスナーを追加する代わりに使用できます。

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

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

パラメーター

eventName

string | symbol

イベントの名前。

listener

(args: any[]) => void

コールバック関数

戻り値

Twin

EventEmitter.on から継承された

once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

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

パラメーター

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

戻り値

Promise<any[]>

EventEmitter.once から継承された

once(EventTarget, string, StaticEventEmitterOptions) 

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

パラメーター

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

戻り値

Promise<any[]>

EventEmitter.once から継承された

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

という名前のイベント listenereventName 関数を追加します。 次回 eventName がトリガーされると、このリスナーが削除され、呼び出されます。

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

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

既定では、イベント リスナーは追加された順序で呼び出されます。 emitter.prependOnceListener() メソッドは、リスナー配列の先頭にイベント リスナーを追加する代わりに使用できます。

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

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

パラメーター

eventName

string | symbol

イベントの名前。

listener

(args: any[]) => void

コールバック関数

戻り値

Twin

EventEmitter.once から継承された

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

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

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

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

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

パラメーター

eventName

string | symbol

イベントの名前。

listener

(args: any[]) => void

コールバック関数

戻り値

Twin

EventEmitter.prependListener から継承された

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

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

パラメーター

eventName

string | symbol

イベントの名前。

listener

(args: any[]) => void

コールバック関数

戻り値

Twin

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

EventEmitter.rawListeners から継承された

removeAllListeners(string | symbol)

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

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

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

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

パラメーター

eventName

string | symbol

戻り値

Twin

EventEmitter.removeAllListeners から継承された

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

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

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

removeListener() は、リスナー配列からリスナーのインスタンスを最大で 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): Twin

パラメーター

eventName

string | symbol

listener

(args: any[]) => void

戻り値

Twin

EventEmitter.removeListener から継承された

setMaxListeners(number)

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

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

function setMaxListeners(n: number): Twin

パラメーター

n

number

戻り値

Twin

EventEmitter.setMaxListeners から継承された

setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 

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

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

setMaxListeners(5, target, emitter);

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

パラメーター

n

number

負以外の数値。 EventTarget イベントあたりのリスナーの最大数。

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

0 個以上の {EventTarget} または {EventEmitter} インスタンス。 何も指定しない場合、n は、新しく作成されたすべての {EventTarget} オブジェクトと {EventEmitter} オブジェクトの既定の最大値として設定されます。

EventEmitter.setMaxListeners から継承された

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

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

パラメーター

error

Error

event

string | symbol

args

AnyRest

EventEmitter.__@captureRejectionSymbol@141 から継承された