ModuleClient class

패키지:
azure-iot-device

Azure IoT Hub와 디바이스를 연결하는 데 사용되는 IoT Hub 디바이스 클라이언트입니다.

SDK 사용자는 팩터리 메서드 중 하나를 호출해야 합니다. fromConnectionString 또는 IoT Hub 디바이스 클라이언트를 만들려면 SharedAccessSignature .

Extends

InternalClient

상속된 속성

captureRejections

값: 불리언

모든 새 EventEmitter 객체의 기본 captureRejections 옵션을 변경하세요.
captureRejectionSymbol

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

맞춤 rejection handler작성법을 확인하세요.
defaultMaxListeners

기본적으로 단일 이벤트에 대해 최대 청 10 취자 수를 등록할 수 있습니다. 이 제한은 이 메서드를 사용하여 emitter.setMaxListeners(n) 개별 EventEmitter 인스턴스에 대해 변경할 수 있습니다. 모든EventEmitter 인스턴스의 기본값을 변경하려면 속성을 events.defaultMaxListeners 사용할 수 있습니다. 이 값이 양수가 아니면 a RangeError 가 던져집니다.

설정을 할 때 events.defaultMaxListeners 는 주의해야 합니다. 변경은 변경 이전에 생성된 인스턴스를 포함해 모든EventEmitter 인스턴스에 영향을 미치기 때문입니다. 하지만 콜링 emitter.setMaxListeners(n) 은 여전히 우선순위가 있습니다 events.defaultMaxListeners.

이것은 엄격한 한계가 아닙니다. 인스턴스는 EventEmitter 더 많은 리스너를 추가할 수 있게 하지만, stderr에 "가능한 EventEmitter 메모리 누수가 감지되었다"는 트레이스 경고를 출력합니다. 임의의 단일 EventEmitter, 에 대해 emitter.getMaxListeners() 와 emitter.setMaxListeners() 메서드를 사용하여 일시적으로 이 경고를 피할 수 있습니다:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

--trace-warnings 명령줄 플래그는 이러한 경고의 스택 트레이스를 표시하는 데 사용할 수 있습니다.

발신된 경고는 추가 emittertypecount , 를 포함해 검사 process.on('warning') 할 수 있으며, 각각 이벤트 방출기 인스턴스, 이벤트 이름, 연결된 청취자 수를 나타냅니다. 그 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)

제공signal된 행사에서 한 번 abort 들어보세요.

중단 신호로 이벤트를 abort 듣는 것은 안전하지 않으며, 신호를 가진 다른 제3자가 호출 e.stopImmediatePropagation()할 수 있어 자원 누출로 이어질 수 있습니다. 안타깝게도 웹 표준을 위반하기 때문에 Node.js 변경할 수 없습니다. 또한, 원래 API는 리스너를 제거하는 것을 쉽게 잊게 만듭니다.

이 API는 이벤트 stopImmediatePropagation 를 듣고 리스너가 실행되는 것을 막지 않게 함으로써 이 두 가지 문제를 해결함으로써 Node.js API에서 s를 안전하게 사용할 AbortSignal수 있게 해줍니다.

일회용 기기를 반품하여 더 쉽게 구독 취소할 수 있습니다.

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이벤트에 대한 수신기 배열의 복사본을 반환합니다.

s에 대해서는 EventEmitter이미터를 호출 .listeners 하는 것과 정확히 동일하게 동작합니다.

s에 대해 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()

EventEmitter 설정되거나 emitter.setMaxListeners(n)기본값인 <xref:EventEmitter.defaultMaxListeners> 대한 현재 최대 수신기 값을 반환합니다.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

현재 설정된 최대 청취자 수를 반환합니다.

s에 대해서는 EventEmitter이미터를 호출 .getMaxListeners 하는 것과 정확히 동일하게 동작합니다.

s에 대해서는 EventTarget이벤트 대상의 최대 이벤트 청취자를 얻는 유일한 방법입니다. 단일 EventTarget의 이벤트 핸들러 수가 최대 집합을 초과하면 EventTarget은 경고를 출력합니다.

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

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}
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

사건을 반복하는 eventName 반환과 AsyncIterator 반환. 만약 이 방출'error'된다 EventEmitter 면 던질 것입니다. 루프를 종료할 때 모든 청취자를 제거합니다. 각 반복에서 반환되는 값 value 은 방출된 이벤트 인자로 구성된 배열입니다.

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

이 a는 주어진 사건을 방출할 때 EventEmitter 성립되거나, 대기 중에 방출 'error' 하면 거부 EventEmitter 되는 a를 만듭니다Promise. Promise will은 주어진 이벤트에 대해 방출된 모든 인수의 배열로 해결됩니다.

이 방법은 의도적으로 일반적이며, 특별한'error' 이벤트 의미론이 없고 이벤트를 'error' 감지하지 않는 웹 플랫폼 EventTarget 인터페이스와 함께 작동합니다.

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)

수신기 배열의 시작 이벤트에 대한 일회성 함수를 추가합니다. 다음에 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() 수신기 배열에서 수신기의 인스턴스를 하나 이상 제거합니다. 단일 수신기가 지정된 eventName대한 수신기 배열에 여러 번 추가된 경우 각 인스턴스를 제거하려면 removeListener() 여러 번 호출해야 합니다.

이벤트가 내보내지면 내보내기 시 연결된 모든 수신기가 순서대로 호출됩니다. 이는 마지막 수신기가 실행을 완료하기 전에 내보내고 후 또는 호출이 진행 중인 제거되지 않음을 의미합니다. 후속 이벤트는 예상대로 동작합니다.

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

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

수신기는 내부 배열을 사용하여 관리되므로 수신기가 제거될 후 등록된 수신기 위치 인덱스가 변경됩니다. 이는 수신기가 호출되는 순서에 영향을 주지 않지만 emitter.listeners() 메서드에서 반환된 수신기 배열의 복사본을 다시 만들어야 한다는 것을 의미합니다.

단일 함수가 단일 이벤트에 대해 처리기로 여러 번 추가된 경우(아래 예제와 같이) removeListener() 가장 최근에 추가된 인스턴스를 제거합니다. 예제에서 once('ping') 수신기가 제거됩니다.

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

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

호출을 연결할 수 있도록 EventEmitter대한 참조를 반환합니다.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

기본적으로 EventEmitter특정 이벤트에 대해 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

값: 불리언

모든 새 EventEmitter 객체의 기본 captureRejections 옵션을 변경하세요.

static captureRejections: boolean

속성 값

boolean

상속됨 내부 클라이언트.캡처거절

captureRejectionSymbol

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

맞춤 rejection handler작성법을 확인하세요.

static captureRejectionSymbol: typeof captureRejectionSymbol

속성 값

typeof captureRejectionSymbol

상속됨 내부 클라이언트.캡처거절심볼

defaultMaxListeners

기본적으로 단일 이벤트에 대해 최대 청 10 취자 수를 등록할 수 있습니다. 이 제한은 이 메서드를 사용하여 emitter.setMaxListeners(n) 개별 EventEmitter 인스턴스에 대해 변경할 수 있습니다. 모든EventEmitter 인스턴스의 기본값을 변경하려면 속성을 events.defaultMaxListeners 사용할 수 있습니다. 이 값이 양수가 아니면 a RangeError 가 던져집니다.

설정을 할 때 events.defaultMaxListeners 는 주의해야 합니다. 변경은 변경 이전에 생성된 인스턴스를 포함해 모든EventEmitter 인스턴스에 영향을 미치기 때문입니다. 하지만 콜링 emitter.setMaxListeners(n) 은 여전히 우선순위가 있습니다 events.defaultMaxListeners.

이것은 엄격한 한계가 아닙니다. 인스턴스는 EventEmitter 더 많은 리스너를 추가할 수 있게 하지만, stderr에 "가능한 EventEmitter 메모리 누수가 감지되었다"는 트레이스 경고를 출력합니다. 임의의 단일 EventEmitter, 에 대해 emitter.getMaxListeners() 와 emitter.setMaxListeners() 메서드를 사용하여 일시적으로 이 경고를 피할 수 있습니다:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

--trace-warnings 명령줄 플래그는 이러한 경고의 스택 트레이스를 표시하는 데 사용할 수 있습니다.

발신된 경고는 추가 emittertypecount , 를 포함해 검사 process.on('warning') 할 수 있으며, 각각 이벤트 방출기 인스턴스, 이벤트 이름, 연결된 청취자 수를 나타냅니다. 그 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 Hub에 대한 인증 매개 변수를 가져오는 데 사용되는 개체입니다.

transportCtor

any

IoT Hub에 연결하는 데 사용되는 전송 프로토콜입니다.

반품

ModuleClient

fromConnectionString(string, any)

지정된 전송 형식을 사용하여 지정된 연결 문자열에서 IoT Hub 디바이스 클라이언트를 만듭니다.

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

매개 변수

connStr

string

IoT Hub에 대한 "디바이스 연결" 권한을 캡슐화하는 연결 문자열입니다.

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 Hub에 연결하는 데 사용되는 전송 프로토콜입니다.

callback

Callback<ModuleClient>

ModuleClient가 생성되었을 때 또는 클라이언트를 만드는 동안 오류가 발생하는 경우 호출할 선택적 콜백입니다.

fromSharedAccessSignature(string, any)

지정된 전송 형식을 사용하여 지정된 공유 액세스 서명에서 IoT Hub 모듈 클라이언트를 만듭니다.

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

매개 변수

sharedAccessSignature

string

IoT Hub에 대한 "디바이스 연결" 권한을 캡슐화하는 공유 액세스 서명입니다.

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)

제공signal된 행사에서 한 번 abort 들어보세요.

중단 신호로 이벤트를 abort 듣는 것은 안전하지 않으며, 신호를 가진 다른 제3자가 호출 e.stopImmediatePropagation()할 수 있어 자원 누출로 이어질 수 있습니다. 안타깝게도 웹 표준을 위반하기 때문에 Node.js 변경할 수 없습니다. 또한, 원래 API는 리스너를 제거하는 것을 쉽게 잊게 만듭니다.

이 API는 이벤트 stopImmediatePropagation 를 듣고 리스너가 실행되는 것을 막지 않게 함으로써 이 두 가지 문제를 해결함으로써 Node.js API에서 s를 안전하게 사용할 AbortSignal수 있게 해줍니다.

일회용 기기를 반품하여 더 쉽게 구독 취소할 수 있습니다.

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 일회용 제품.

상속됨 내부 클라이언트. addAbort리스너

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이벤트에 대한 수신기 배열의 복사본을 반환합니다.

s에 대해서는 EventEmitter이미터를 호출 .listeners 하는 것과 정확히 동일하게 동작합니다.

s에 대해 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()

EventEmitter 설정되거나 emitter.setMaxListeners(n)기본값인 <xref:EventEmitter.defaultMaxListeners> 대한 현재 최대 수신기 값을 반환합니다.

function getMaxListeners(): number

반품

number

InternalClient.getMaxListeners에서 상속된

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

현재 설정된 최대 청취자 수를 반환합니다.

s에 대해서는 EventEmitter이미터를 호출 .getMaxListeners 하는 것과 정확히 동일하게 동작합니다.

s에 대해서는 EventTarget이벤트 대상의 최대 이벤트 청취자를 얻는 유일한 방법입니다. 단일 EventTarget의 이벤트 핸들러 수가 최대 집합을 초과하면 EventTarget은 경고를 출력합니다.

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

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

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

매개 변수

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

사건을 반복하는 eventName 반환과 AsyncIterator 반환. 만약 이 방출'error'된다 EventEmitter 면 던질 것입니다. 루프를 종료할 때 모든 청취자를 제거합니다. 각 반복에서 반환되는 값 value 은 방출된 이벤트 인자로 구성된 배열입니다.

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

이 a는 주어진 사건을 방출할 때 EventEmitter 성립되거나, 대기 중에 방출 'error' 하면 거부 EventEmitter 되는 a를 만듭니다Promise. Promise will은 주어진 이벤트에 대해 방출된 모든 인수의 배열로 해결됩니다.

이 방법은 의도적으로 일반적이며, 특별한'error' 이벤트 의미론이 없고 이벤트를 'error' 감지하지 않는 웹 플랫폼 EventTarget 인터페이스와 함께 작동합니다.

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)

수신기 배열의 시작 이벤트에 대한 일회성 함수를 추가합니다. 다음에 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() 수신기 배열에서 수신기의 인스턴스를 하나 이상 제거합니다. 단일 수신기가 지정된 eventName대한 수신기 배열에 여러 번 추가된 경우 각 인스턴스를 제거하려면 removeListener() 여러 번 호출해야 합니다.

이벤트가 내보내지면 내보내기 시 연결된 모든 수신기가 순서대로 호출됩니다. 이는 마지막 수신기가 실행을 완료하기 전에 내보내고 후 또는 호출이 진행 중인 제거되지 않음을 의미합니다. 후속 이벤트는 예상대로 동작합니다.

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

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

수신기는 내부 배열을 사용하여 관리되므로 수신기가 제거될 후 등록된 수신기 위치 인덱스가 변경됩니다. 이는 수신기가 호출되는 순서에 영향을 주지 않지만 emitter.listeners() 메서드에서 반환된 수신기 배열의 복사본을 다시 만들어야 한다는 것을 의미합니다.

단일 함수가 단일 이벤트에 대해 처리기로 여러 번 추가된 경우(아래 예제와 같이) removeListener() 가장 최근에 추가된 인스턴스를 제거합니다. 예제에서 once('ping') 수신기가 제거됩니다.

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

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

호출을 연결할 수 있도록 EventEmitter대한 참조를 반환합니다.

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

기본적으로 EventEmitter특정 이벤트에 대해 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)[]

{EventTarget} 또는 {EventEmitter} 인스턴스가 0개 이상입니다. 만약 지정이 없으면, 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