ModuleClient class

リファレンス

パッケージ:: azure-iot-device

デバイスを Azure IoT Hub に接続するために使用される IoT Hub デバイスクライアント。

SDK のユーザーは、ファクトリメソッドのいずれかを呼び出す必要があります。fromConnectionString または SharedAccessSignature からして IoT Hub デバイスクライアントを作成します。

Extends: InternalClient

継承されたプロパティ

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'` リスナーがインストールされていない場合でも、プロセスはクラッシュします。

メソッド

close()
close(Callback<Disconnected>)	トランスポート接続を閉じ、クライアントリソースを破棄します。注: このメソッドを呼び出した後、ModuleClient オブジェクトを再利用することはできません。
fromAuthenticationProvider(AuthenticationProvider, any)	指定された認証方法から、指定されたトランスポートの種類を使用して、IoT Hub モジュールクライアントを作成します。
fromConnectionString(string, any)	指定したトランスポートの種類を使用して、指定された接続文字列から IoT Hub デバイスクライアントを作成します。
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)	環境の構成情報を使用して IoT Hub モジュールクライアントを作成します。 `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 Hub モジュールクライアントを作成します。
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)	指定された `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)`のエイリアス。
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()	エミッターがリスナーを登録したイベントを一覧表示する配列を返します。配列内の値は文字列または `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 }`
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 \| 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`
open()
open(Callback<Connected>)
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');
reject(Message)
reject(Message, Callback<MessageRejected>)
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`への参照を返します。
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	既定では、`EventEmitter`s は、特定のイベントに対して `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);`
setRetryPolicy(RetryPolicy)	すべての操作でクライアントによって使用される再試行ポリシーを設定します。既定値は ExponentialBackoffWithJitterです。
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

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

captureRejections

値: ブール

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

static captureRejections: boolean

プロパティ値

boolean

InternalClient.captureRejections から継承された

captureRejectionSymbol

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

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

static captureRejectionSymbol: typeof captureRejectionSymbol

プロパティ値

typeof captureRejectionSymbol

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

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 Hub モジュールクライアントを作成します。

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

パラメーター

authenticationProvider: AuthenticationProvider

IoT ハブの認証パラメーターを取得するために使用されるオブジェクト。

transportCtor: any

IoT ハブへの接続に使用されるトランスポートプロトコル。

戻り値

ModuleClient

fromConnectionString(string, any)

指定したトランスポートの種類を使用して、指定された接続文字列から IoT Hub デバイスクライアントを作成します。

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 Hub モジュールクライアントを作成します。

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 Hub モジュールクライアントを作成します。

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

パラメーター

sharedAccessSignature: string

IoT ハブの "デバイス接続" アクセス許可をカプセル化する Shared Access Signature。

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)

指定された 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 リスナーを削除する破棄可能。

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()

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

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

InternalClient.getEventListeners から継承された

getMaxListeners()

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

function getMaxListeners(): number

戻り値

number

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

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

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

InternalClient.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): ModuleClient

パラメーター

eventName: string | symbol

イベントの名前。

listener: (args: any[]) => void

コールバック関数

戻り値

ModuleClient

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

InternalClient.once から継承された

once(EventTarget, string, StaticEventEmitterOptions)

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

パラメーター

emitter: EventTarget

eventName: string

options: StaticEventEmitterOptions

戻り値

Promise<any[]>

InternalClient.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): 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 が複数回追加され、呼び出されます。

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)

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

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

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

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

function setMaxListeners(n: number): ModuleClient

パラメーター

n: number

戻り値

ModuleClient

internalClient.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} オブジェクトの既定の最大値として設定されます。

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@141 から継承された

次の方法で共有

ModuleClient class

継承されたプロパティ

メソッド

継承されたメソッド

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

captureRejections

プロパティ値

captureRejectionSymbol

プロパティ値

defaultMaxListeners

プロパティ値

errorMonitor

プロパティ値

メソッドの詳細

close()

戻り値

close(Callback<Disconnected>)

パラメーター

fromAuthenticationProvider(AuthenticationProvider, any)

パラメーター

戻り値

fromConnectionString(string, any)

パラメーター

戻り値

fromEnvironment(any)

パラメーター

戻り値

fromEnvironment(any, Callback<ModuleClient>)

パラメーター

fromSharedAccessSignature(string, any)

パラメーター

戻り値

invokeMethod(string, MethodParams)

パラメーター

戻り値

invokeMethod(string, MethodParams, Callback<MethodResult>)

パラメーター

invokeMethod(string, string, MethodParams)

パラメーター

戻り値

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

パラメーター

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

パラメーター

sendOutputEvent(string, Message)

パラメーター

戻り値

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

パラメーター

sendOutputEventBatch(string, Message[])

パラメーター

戻り値

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

パラメーター

setOptions(DeviceClientOptions)

パラメーター

戻り値

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

パラメーター

継承済みメソッドの詳細

abandon(Message)

パラメーター

戻り値

abandon(Message, Callback<MessageAbandoned>)

パラメーター

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

パラメーター

戻り値

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

パラメーター

戻り値

complete(Message)

パラメーター

戻り値

complete(Message, Callback<MessageCompleted>)

パラメーター

emit<K>(string | symbol, AnyRest)

パラメーター

戻り値