Aracılığıyla paylaş

ModuleClient class

  • Başvuru
Paket:
azure-iot-device

Bir cihazı Azure IoT hub'ına bağlamak için kullanılan IoT Hub cihaz istemcisi.

SDK kullanıcıları, IoT Hub cihaz istemcisi oluşturmak içinConnectionString veyaSharedAccessSignature'dan fabrika yöntemlerinden birini çağırmalıdır.

Extends

InternalClient

Devralınan Özellikler

captureRejections

Değer: boole

Tüm yeni EventEmitter nesnelerinde varsayılan captureRejections seçeneğini değiştirin.
captureRejectionSymbol

Değer: Symbol.for('nodejs.rejection')

Özel rejection handleryazmayı öğrenin.
defaultMaxListeners

Varsayılan olarak, herhangi bir olay için en fazla 10 dinleyici kaydedilebilir. Bu sınır, emitter.setMaxListeners(n) yöntemi kullanılarak tek tek EventEmitter örnekleri için değiştirilebilir. Tüm örnekleri varsayılan değerini değiştirmek için özelliği kullanılabilir. Bu değer pozitif bir sayı değilse, bir RangeError oluşturulur.

Değişiklik, değişiklik yapılmadan önce oluşturulanlar da dahil olmak üzere tüm örnekleri etkileyeceğinden, ayarlarken dikkatli olun. Ancak, emitter.setMaxListeners(n) çağırma işleminin events.defaultMaxListeners'den daha önceliklidir.

Bu sabit bir sınır değildir. EventEmitter örneği daha fazla dinleyici eklenmesine izin verir, ancak stderr'a "olası EventEmitter bellek sızıntısı" algılandığını belirten bir izleme uyarısı verir. Herhangi bir tek EventEmitteriçin, bu uyarıyı geçici olarak önlemek için emitter.getMaxListeners() ve emitter.setMaxListeners() yöntemleri kullanılabilir:

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 komut satırı bayrağı, bu tür uyarıların yığın izlemesini görüntülemek için kullanılabilir.

Yayılan uyarı process.on('warning') ile incelenebilir ve ek emitter, typeve count özelliklerine sahip olur ve sırasıyla olay verici örneğine, olayın adına ve ekli dinleyici sayısına başvurur. name özelliği 'MaxListenersExceededWarning'olarak ayarlanır.
errorMonitor

Bu sembol yalnızca izleme 'error' olayları için bir dinleyici yüklemek için kullanılacaktır. Bu simge kullanılarak yüklenen dinleyiciler, normal 'error' dinleyiciler çağrılmadan önce çağrılır.

Bu simgeyi kullanarak dinleyici yüklemek, 'error' bir olay yayımlandıktan sonra davranışı değiştirmez. Bu nedenle, normal 'error' dinleyici yüklü değilse işlem yine de kilitlenir.

Yöntemler

close()
close(Callback<Disconnected>)

Aktarım bağlantısını kapatır ve istemci kaynaklarını yok eder.

Not: Bu yöntem çağrıldıktan sonra ModuleClient nesnesi yeniden kullanılamaz.
fromAuthenticationProvider(AuthenticationProvider, any)

Verilen kimlik doğrulama yönteminden ve verilen aktarım türünü kullanarak bir IoT Hub modülü istemcisi oluşturur.
fromConnectionString(string, any)

Verilen aktarım türünü kullanarak verilen bağlantı dizesinden bir IoT Hub cihaz istemcisi oluşturur.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Ortamdaki yapılandırma bilgilerini kullanarak bir IoT Hub modülü istemcisi oluşturur.

EdgeHubConnectionString veya IotHubConnectionString adlı bir ortam değişkeni varsa, bu değer kullanılır ve davranış, bunu fromConnectionString geçirmek için çağrılmasıyla aynıdır. Bu ortam değişkenleri yoksa aşağıdaki değişkenler tanımlanmalıdır:

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

Verilen aktarım türünü kullanarak verilen paylaşılan erişim imzasından bir IoT Hub modülü istemcisi oluşturur.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Aşağı akış cihazında veya aynı IoTEdge cihazındaki başka bir modülde bir yöntemi çağırır. Bu özelliğin yalnızca modül bir IoTEdge cihazının parçası olarak çalıştırıldığında çalıştığını unutmayın.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

methodNameadlı bir yöntem için geri çağırma kaydeder.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Verilen modül çıkışına bir olay gönderir
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Verilen modül çıkışına bir olay dizisi gönderir
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Taşımayı yapılandırmak için kullanılabilecek ModuleClient nesnesine seçenekleri geçirir.

Devralınan Yöntemler

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)

Sağlanan signalabort olayını bir kez dinler.

durdurma sinyallerinde abort olayını dinlemek güvenli değildir ve sinyale sahip başka bir üçüncü taraf e.stopImmediatePropagation()çağırabileceğinden kaynak sızıntılarına yol açabilir. Ne yazık ki Node.js web standardını ihlal ettiğinden bunu değiştiremez. Ayrıca, özgün API dinleyicileri kaldırmayı unutmayı kolaylaştırır.

Bu API, stopImmediatePropagation dinleyicinin çalışmasını engelleyecek şekilde olayı dinleyerek bu iki sorunu çözerek Node.js API'lerinde AbortSignalgüvenli bir şekilde kullanılmasına olanak tanır.

Aboneliğinin daha kolay kaldırılabilmesi için atılabilir bir değer döndürür.

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)için diğer ad.
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

eventNameadlı olay için kaydedilen dinleyicilerin her birini, kaydedildikleri sırayla zaman uyumlu olarak çağırır ve sağlanan bağımsız değişkenleri her birine geçirir.

Olayın dinleyicileri varsa true döndürür, aksi takdirde 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()

Vericinin dinleyicileri kaydettiği olayları listeleyen bir dizi döndürür. Dizideki değerler dizeler veya Symbol'lerdir.

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)

eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

EventEmitteriçin bu, yayımlayıcıda .listeners çağırmakla tam olarak aynı şekilde davranır.

EventTargetiçin olay hedefi için olay dinleyicilerini almanın tek yolu budur. Bu, hata ayıklama ve tanılama amacıyla kullanışlıdır.

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

emitter.setMaxListeners(n) tarafından ayarlanan veya varsayılan olarak defaultMaxListenersolan EventEmitter için geçerli en yüksek dinleyici değerini döndürür.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Şu anda ayarlanmış en fazla dinleyici miktarını döndürür.

EventEmitteriçin bu, yayımlayıcıda .getMaxListeners çağırmakla tam olarak aynı şekilde davranır.

EventTargetiçin, olay hedefi için en fazla olay dinleyicisini almanın tek yolu budur. Tek bir EventTarget üzerindeki olay işleyicilerinin sayısı maksimum kümeyi aşarsa, EventTarget bir uyarı yazdırır.

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)

Verilen emitterkayıtlı verilen eventName için dinleyici sayısını döndüren bir sınıf yöntemi.

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)

eventNameadlı olayı dinleyen dinleyici sayısını döndürür. listener sağlanırsa, dinleyicinin olay dinleyicileri listesinde kaç kez bulunduğunu döndürür.
listeners<K>(string | symbol)

eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

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()için diğer ad.
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 olayları yineleyen bir AsyncIterator döndürür. EventEmitter 'error'yayıyorsa atar. Döngüden çıkarken tüm dinleyicileri kaldırır. Her yineleme tarafından döndürülen value, yayılan olay bağımsız değişkenlerinden oluşan bir dizidir.

Olayları beklemeyi iptal etmek için bir AbortSignal kullanılabilir:

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

Yinelemeyi sonlandıracak bir olay adları dizisi belirtmek için close seçeneğini kullanın:

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 işlevini eventNameadlı olay için dinleyiciler dizisinin sonuna ekler. listener eklenip eklenmediğini görmek için denetim yapılmaz. aynı eventName ve listener birleşimini geçen birden çok çağrı, listener birden çok kez eklenmesine ve çağrılmasını sağlar.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

Varsayılan olarak, olay dinleyicileri eklendikleri sırayla çağrılır. emitter.prependListener() yöntemi, olay dinleyicisini dinleyici dizisinin başına eklemek için alternatif olarak kullanılabilir.

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)

EventEmitter belirli bir olayı yaydığında gerçekleştirilen veya EventEmitter beklerken 'error' yaydığında reddedilen bir Promise oluşturur. Promise, verilen olaya yayılan tüm bağımsız değişkenleri içeren bir diziyle çözümlenir.

Bu yöntem kasıtlı olarak geneldir ve özel olay semantiği olmayan ve olayı dinlemeyen EventTarget arabirimi web platformuyla çalışır.

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' olayının özel işlemesi yalnızca başka bir olayı beklemek için events.once() kullanıldığında kullanılır. 'error' olayının kendisini beklemek için events.once() kullanılırsa, özel işleme olmadan başka herhangi bir olay türü olarak değerlendirilir:

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

Bir AbortSignal, olayı beklemeyi iptal etmek için kullanılabilir:

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)

eventNameadlı olay için tek seferlik bir listener işlevi ekler. eventName bir sonraki tetiklendiğinde, bu dinleyici kaldırılır ve çağrılır.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

Varsayılan olarak, olay dinleyicileri eklendikleri sırayla çağrılır. emitter.prependOnceListener() yöntemi, olay dinleyicisini dinleyici dizisinin başına eklemek için alternatif olarak kullanılabilir.

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)

işlevini, adlı olay için dinleyiciler dizisinin başlayan ekler. listener eklenip eklenmediğini görmek için denetim yapılmaz. aynı eventName ve listener birleşimini geçen birden çok çağrı, listener birden çok kez eklenmesine ve çağrılmasını sağlar.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

dinleyiciler dizisinin başlayan adlı olay için tek seferlik bir işlevi ekler. eventName bir sonraki tetiklendiğinde, bu dinleyici kaldırılır ve sonra çağrılır.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.
rawListeners<K>(string | symbol)

tüm sarmalayıcılar (.once()tarafından oluşturulanlar gibi) dahil olmak üzere eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

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)

Tüm dinleyicileri veya belirtilen eventNameolanları kaldırır.

Özellikle EventEmitter örneği başka bir bileşen veya modül (örneğin yuvalar veya dosya akışları) tarafından oluşturulduğunda kodun başka bir yerine eklenen dinleyicileri kaldırmak kötü bir uygulamadır.

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.
removeListener<K>(string | symbol, (args: any[]) => void)

eventNameadlı olay için dinleyici dizisinden belirtilen listener kaldırır.

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

removeListener() dinleyici dizisinden en fazla bir dinleyici örneğini kaldırır. Belirtilen eventNameiçin dinleyici dizisine birden çok kez tek bir dinleyici eklendiyse, her örneği kaldırmak için removeListener() birden çok kez çağrılmalıdır.

Bir olay yayımlandıktan sonra, yayma sırasında ona eklenen tüm dinleyiciler sırayla çağrılır. Bu, son dinleyici yürütmeyi bitirmeden önce veya çağrısının yürütmeyi bitirmeden önce veya çağrılarının devam eden kaldırmayacağını gösterir. Sonraki olaylar beklendiği gibi davranır.

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

Dinleyiciler bir iç dizi kullanılarak yönetildiğinden, bu çağrının çağrılması, dinleyici kaldırıldıktan sonra kaydedilen tüm dinleyicilerin konum dizinlerini değiştirir. Bu, dinleyicilerin çağrılma sırasını etkilemez, ancak emitter.listeners() yöntemi tarafından döndürülen dinleyici dizisi kopyalarının yeniden oluşturulması gerektiği anlamına gelir.

Tek bir işlev tek bir olay için birden çok kez işleyici olarak eklendiğinde (aşağıdaki örnekte olduğu gibi), removeListener() en son eklenen örneği kaldırır. Örnekte once('ping') dinleyicisi kaldırılır:

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');

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Varsayılan olarak, belirli bir olay için 10'den fazla dinleyici eklenirse EventEmitterbir uyarı yazdırır. Bu, bellek sızıntılarını bulmaya yardımcı olan kullanışlı bir varsayılan değerdir. emitter.setMaxListeners() yöntemi, sınırın bu belirli EventEmitter örneği için değiştirilmesini sağlar. Değer, sınırsız sayıda dinleyiciyi göstermek için Infinity (veya 0) olarak ayarlanabilir.

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.
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)

İstemci tarafından tüm işlemlerde kullanılan yeniden deneme ilkesini ayarlar. Varsayılan değer ExponentialBackoffWithJitter'dir.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Devralınan Özellik Detayları

captureRejections

Değer: boole

Tüm yeni EventEmitter nesnelerinde varsayılan captureRejections seçeneğini değiştirin.

static captureRejections: boolean

Özellik Değeri

boolean

InternalClient.captureRejections'tan Devralınan

captureRejectionSymbol

Değer: Symbol.for('nodejs.rejection')

Özel rejection handleryazmayı öğrenin.

static captureRejectionSymbol: typeof captureRejectionSymbol

Özellik Değeri

typeof captureRejectionSymbol

InternalClient.captureRejectionSymbol'dan Devralınan

defaultMaxListeners

Varsayılan olarak, herhangi bir olay için en fazla 10 dinleyici kaydedilebilir. Bu sınır, emitter.setMaxListeners(n) yöntemi kullanılarak tek tek EventEmitter örnekleri için değiştirilebilir. Tüm örnekleri varsayılan değerini değiştirmek için özelliği kullanılabilir. Bu değer pozitif bir sayı değilse, bir RangeError oluşturulur.

Değişiklik, değişiklik yapılmadan önce oluşturulanlar da dahil olmak üzere tüm örnekleri etkileyeceğinden, ayarlarken dikkatli olun. Ancak, emitter.setMaxListeners(n) çağırma işleminin events.defaultMaxListeners'den daha önceliklidir.

Bu sabit bir sınır değildir. EventEmitter örneği daha fazla dinleyici eklenmesine izin verir, ancak stderr'a "olası EventEmitter bellek sızıntısı" algılandığını belirten bir izleme uyarısı verir. Herhangi bir tek EventEmitteriçin, bu uyarıyı geçici olarak önlemek için emitter.getMaxListeners() ve emitter.setMaxListeners() yöntemleri kullanılabilir:

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 komut satırı bayrağı, bu tür uyarıların yığın izlemesini görüntülemek için kullanılabilir.

Yayılan uyarı process.on('warning') ile incelenebilir ve ek emitter, typeve count özelliklerine sahip olur ve sırasıyla olay verici örneğine, olayın adına ve ekli dinleyici sayısına başvurur. name özelliği 'MaxListenersExceededWarning'olarak ayarlanır.

static defaultMaxListeners: number

Özellik Değeri

number

InternalClient.defaultMaxListeners Devralındı

errorMonitor

Bu sembol yalnızca izleme 'error' olayları için bir dinleyici yüklemek için kullanılacaktır. Bu simge kullanılarak yüklenen dinleyiciler, normal 'error' dinleyiciler çağrılmadan önce çağrılır.

Bu simgeyi kullanarak dinleyici yüklemek, 'error' bir olay yayımlandıktan sonra davranışı değiştirmez. Bu nedenle, normal 'error' dinleyici yüklü değilse işlem yine de kilitlenir.

static errorMonitor: typeof errorMonitor

Özellik Değeri

typeof errorMonitor

InternalClient.errorMonitor'dan Devralınan

Yöntem Ayrıntıları

close() 

function close(): Promise<Disconnected>

Döndürülenler

Promise<Disconnected>

close(Callback<Disconnected>)

Aktarım bağlantısını kapatır ve istemci kaynaklarını yok eder.

Not: Bu yöntem çağrıldıktan sonra ModuleClient nesnesi yeniden kullanılamaz.

function close(closeCallback?: Callback<Disconnected>)

Parametreler

closeCallback

Callback<Disconnected>

Aktarım bağlantısı kesildiğinde ve istemci kapatıldıktan sonra çağrılacak isteğe bağlı işlev.

fromAuthenticationProvider(AuthenticationProvider, any)

Verilen kimlik doğrulama yönteminden ve verilen aktarım türünü kullanarak bir IoT Hub modülü istemcisi oluşturur.

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

Parametreler

authenticationProvider

AuthenticationProvider

IoT hub'ına yönelik kimlik doğrulama parametrelerini almak için kullanılan nesne.

transportCtor

any

IoT hub'ına bağlanmak için kullanılan aktarım protokolü.

Döndürülenler

ModuleClient

fromConnectionString(string, any)

Verilen aktarım türünü kullanarak verilen bağlantı dizesinden bir IoT Hub cihaz istemcisi oluşturur.

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

Parametreler

connStr

string

IoT hub'ındaki "cihaz bağlantısı" izinlerini kapsülleyen bağlantı dizesi.

transportCtor

any

Bir taşıma oluşturucu.

Döndürülenler

ModuleClient

fromEnvironment(any) 

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Parametreler

transportCtor

any

Döndürülenler

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Ortamdaki yapılandırma bilgilerini kullanarak bir IoT Hub modülü istemcisi oluşturur.

EdgeHubConnectionString veya IotHubConnectionString adlı bir ortam değişkeni varsa, bu değer kullanılır ve davranış, bunu fromConnectionString geçirmek için çağrılmasıyla aynıdır. Bu ortam değişkenleri yoksa aşağıdaki değişkenler tanımlanmalıdır:

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

Parametreler

transportCtor

any

IoT hub'ına bağlanmak için kullanılan aktarım protokolü.

callback

Callback<ModuleClient>

ModuleClient oluşturulduğunda veya istemci oluşturulurken bir hata oluşursa çağrılacak isteğe bağlı geri çağırma.

fromSharedAccessSignature(string, any)

Verilen aktarım türünü kullanarak verilen paylaşılan erişim imzasından bir IoT Hub modülü istemcisi oluşturur.

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

Parametreler

sharedAccessSignature

string

IoT hub'ındaki "cihaz bağlantısı" izinlerini kapsülleyen paylaşılan erişim imzası.

transportCtor

any

Döndürülenler

ModuleClient

invokeMethod(string, MethodParams) 

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Parametreler

deviceId

string

methodParams

MethodParams

Döndürülenler

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Aşağı akış cihazında veya aynı IoTEdge cihazındaki başka bir modülde bir yöntemi çağırır. Bu özelliğin yalnızca modül bir IoTEdge cihazının parçası olarak çalıştırıldığında çalıştığını unutmayın.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Parametreler

deviceId

string

hedef cihaz tanımlayıcısı

methodParams

MethodParams

doğrudan yöntem çağrısının parametreleri

callback

Callback<MethodResult>

bir Error nesnesiyle veya yöntem çağrısının sonucuyla çağrılacak isteğe bağlı geri çağırma.

invokeMethod(string, string, MethodParams) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Parametreler

deviceId

string

moduleId

string

methodParams

MethodParams

Döndürülenler

Promise<MethodResult>

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

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Parametreler

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

methodNameadlı bir yöntem için geri çağırma kaydeder.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parametreler

methodName

string

Geri çağırma tarafından işlenecek yöntemin adı

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

methodName adlı yöntem için bir yöntem isteği alındığında çağrılacak işlev.

sendOutputEvent(string, Message) 

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Parametreler

outputName

string

message
Message

Döndürülenler

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Verilen modül çıkışına bir olay gönderir

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Parametreler

outputName

string

Olayı gönderecek çıkışın adı

message
Message

Verilen çıkışa gönderilecek ileti

callback

Callback<MessageEnqueued>

İşlem kuyruğa alınırken çağrılacak isteğe bağlı işlev.

sendOutputEventBatch(string, Message[]) 

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Parametreler

outputName

string

messages

Message[]

Döndürülenler

Promise<MessageEnqueued>

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

Verilen modül çıkışına bir olay dizisi gönderir

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Parametreler

outputName

string

Olayları gönderecek çıkışın adı

messages

Message[]

callback

Callback<MessageEnqueued>

İşlemler kuyruğa alındığında çağrılacak işlev.

setOptions(DeviceClientOptions) 

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

Parametreler

options
DeviceClientOptions

Döndürülenler

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Taşımayı yapılandırmak için kullanılabilecek ModuleClient nesnesine seçenekleri geçirir.

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

Parametreler

options
DeviceClientOptions

DeviceClientOptions nesnesi.

done

Callback<TransportConfigured>

Seçenekler ayarlandıktan sonra çağrılacak isteğe bağlı geri arama.

Devralınan Yöntemin Ayrıntıları

abandon(Message) 

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

Parametreler

message
Message

Döndürülenler

Promise<MessageAbandoned>

InternalClient.abandon Devralındı

abandon(Message, Callback<MessageAbandoned>) 

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

Parametreler

message
Message
abandonCallback

Callback<MessageAbandoned>

InternalClient.abandon Devralındı

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

Sağlanan signalabort olayını bir kez dinler.

durdurma sinyallerinde abort olayını dinlemek güvenli değildir ve sinyale sahip başka bir üçüncü taraf e.stopImmediatePropagation()çağırabileceğinden kaynak sızıntılarına yol açabilir. Ne yazık ki Node.js web standardını ihlal ettiğinden bunu değiştiremez. Ayrıca, özgün API dinleyicileri kaldırmayı unutmayı kolaylaştırır.

Bu API, stopImmediatePropagation dinleyicinin çalışmasını engelleyecek şekilde olayı dinleyerek bu iki sorunu çözerek Node.js API'lerinde AbortSignalgüvenli bir şekilde kullanılmasına olanak tanır.

Aboneliğinin daha kolay kaldırılabilmesi için atılabilir bir değer döndürür.

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

Parametreler

signal

AbortSignal

resource

(event: Event) => void

Döndürülenler

Disposable

abort dinleyicisini kaldıran atılabilir.

InternalClient.addAbortListener'dan Devralınan

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

emitter.on(eventName, listener)için diğer ad.

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

ModuleClient

InternalClient.addListener'dan Devralınan

complete(Message) 

function complete(message: Message): Promise<MessageCompleted>

Parametreler

message
Message

Döndürülenler

Promise<MessageCompleted>

InternalClient.complete Devralındı

complete(Message, Callback<MessageCompleted>) 

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parametreler

message
Message
completeCallback

Callback<MessageCompleted>

InternalClient.complete Devralındı

emit<K>(string | symbol, AnyRest)

eventNameadlı olay için kaydedilen dinleyicilerin her birini, kaydedildikleri sırayla zaman uyumlu olarak çağırır ve sağlanan bağımsız değişkenleri her birine geçirir.

Olayın dinleyicileri varsa true döndürür, aksi takdirde 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

Parametreler

eventName

string | symbol

args

AnyRest

Döndürülenler

boolean

InternalClient.emit'den Devralınmış

eventNames()

Vericinin dinleyicileri kaydettiği olayları listeleyen bir dizi döndürür. Dizideki değerler dizeler veya Symbol'lerdir.

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

Döndürülenler

(string | symbol)[]

InternalClient.eventNames'ten Devralınan

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

EventEmitteriçin bu, yayımlayıcıda .listeners çağırmakla tam olarak aynı şekilde davranır.

EventTargetiçin olay hedefi için olay dinleyicilerini almanın tek yolu budur. Bu, hata ayıklama ve tanılama amacıyla kullanışlıdır.

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

Parametreler

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Döndürülenler

Function[]

InternalClient.getEventListeners'dan Devralınan

getMaxListeners()

emitter.setMaxListeners(n) tarafından ayarlanan veya varsayılan olarak defaultMaxListenersolan EventEmitter için geçerli en yüksek dinleyici değerini döndürür.

function getMaxListeners(): number

Döndürülenler

number

InternalClient.getMaxListeners'dan Devralınan

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Şu anda ayarlanmış en fazla dinleyici miktarını döndürür.

EventEmitteriçin bu, yayımlayıcıda .getMaxListeners çağırmakla tam olarak aynı şekilde davranır.

EventTargetiçin, olay hedefi için en fazla olay dinleyicisini almanın tek yolu budur. Tek bir EventTarget üzerindeki olay işleyicilerinin sayısı maksimum kümeyi aşarsa, EventTarget bir uyarı yazdırır.

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

Parametreler

emitter

EventEmitter<DefaultEventMap> | EventTarget

Döndürülenler

number

InternalClient.getMaxListeners'dan Devralınan

getTwin() 

function getTwin(): Promise<Twin>

Döndürülenler

Promise<Twin>

InternalClient.getTwin'den Devralınan

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parametreler

done

Callback<Twin>

InternalClient.getTwin'den Devralınan

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Uyarı

Bu API artık kullanım dışıdır.

Since v3.2.0 - Use listenerCount instead.

Verilen emitterkayıtlı verilen eventName için dinleyici sayısını döndüren bir sınıf yöntemi.

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

Parametreler

emitter

EventEmitter<DefaultEventMap>

Sorguya yayımlayıcı

eventName

string | symbol

Olay adı

Döndürülenler

number

InternalClient.listenerCount'dan Devralınan

listenerCount<K>(string | symbol, Function)

eventNameadlı olayı dinleyen dinleyici sayısını döndürür. listener sağlanırsa, dinleyicinin olay dinleyicileri listesinde kaç kez bulunduğunu döndürür.

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

Parametreler

eventName

string | symbol

Dinlenen olayın adı

listener

Function

Olay işleyici işlevi

Döndürülenler

number

InternalClient.listenerCount'dan Devralınan

listeners<K>(string | symbol)

eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<K>(eventName: string | symbol): Function[]

Parametreler

eventName

string | symbol

Döndürülenler

Function[]

InternalClient.listeners'dan Devralınan

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

emitter.removeListener()için diğer ad.

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

ModuleClient

InternalClient.off'tan Devralınmış

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 olayları yineleyen bir AsyncIterator döndürür. EventEmitter 'error'yayıyorsa atar. Döngüden çıkarken tüm dinleyicileri kaldırır. Her yineleme tarafından döndürülen value, yayılan olay bağımsız değişkenlerinden oluşan bir dizidir.

Olayları beklemeyi iptal etmek için bir AbortSignal kullanılabilir:

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

Yinelemeyi sonlandıracak bir olay adları dizisi belirtmek için close seçeneğini kullanın:

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

const ee = new EventEmitter();

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

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterableIterator<any[]>

Parametreler

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Döndürülenler

AsyncIterableIterator<any[]>

emitter tarafından yayılan eventName olayları yineleyen bir AsyncIterator

InternalClient.on'dan Devralındı

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Parametreler

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Döndürülenler

AsyncIterableIterator<any[]>

InternalClient.on'dan Devralındı

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

listener işlevini eventNameadlı olay için dinleyiciler dizisinin sonuna ekler. listener eklenip eklenmediğini görmek için denetim yapılmaz. aynı eventName ve listener birleşimini geçen birden çok çağrı, listener birden çok kez eklenmesine ve çağrılmasını sağlar.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

Varsayılan olarak, olay dinleyicileri eklendikleri sırayla çağrılır. emitter.prependListener() yöntemi, olay dinleyicisini dinleyici dizisinin başına eklemek için alternatif olarak kullanılabilir.

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

Parametreler

eventName

string | symbol

Olayın adı.

listener

(args: any[]) => void

Geri çağırma işlevi

Döndürülenler

ModuleClient

InternalClient.on'dan Devralındı

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

EventEmitter belirli bir olayı yaydığında gerçekleştirilen veya EventEmitter beklerken 'error' yaydığında reddedilen bir Promise oluşturur. Promise, verilen olaya yayılan tüm bağımsız değişkenleri içeren bir diziyle çözümlenir.

Bu yöntem kasıtlı olarak geneldir ve özel olay semantiği olmayan ve olayı dinlemeyen EventTarget arabirimi web platformuyla çalışır.

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' olayının özel işlemesi yalnızca başka bir olayı beklemek için events.once() kullanıldığında kullanılır. 'error' olayının kendisini beklemek için events.once() kullanılırsa, özel işleme olmadan başka herhangi bir olay türü olarak değerlendirilir:

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

Bir AbortSignal, olayı beklemeyi iptal etmek için kullanılabilir:

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

Parametreler

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Döndürülenler

Promise<any[]>

InternalClient.once Devralındı

once(EventTarget, string, StaticEventEmitterOptions) 

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

Parametreler

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Döndürülenler

Promise<any[]>

InternalClient.once Devralındı

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

eventNameadlı olay için tek seferlik bir listener işlevi ekler. eventName bir sonraki tetiklendiğinde, bu dinleyici kaldırılır ve çağrılır.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

Varsayılan olarak, olay dinleyicileri eklendikleri sırayla çağrılır. emitter.prependOnceListener() yöntemi, olay dinleyicisini dinleyici dizisinin başına eklemek için alternatif olarak kullanılabilir.

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

Parametreler

eventName

string | symbol

Olayın adı.

listener

(args: any[]) => void

Geri çağırma işlevi

Döndürülenler

ModuleClient

InternalClient.once Devralındı

open() 

function open(): Promise<Connected>

Döndürülenler

Promise<Connected>

InternalClient.open Devralındı

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parametreler

openCallback

Callback<Connected>

InternalClient.open Devralındı

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

işlevini, adlı olay için dinleyiciler dizisinin başlayan ekler. listener eklenip eklenmediğini görmek için denetim yapılmaz. aynı eventName ve listener birleşimini geçen birden çok çağrı, listener birden çok kez eklenmesine ve çağrılmasını sağlar.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

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

Parametreler

eventName

string | symbol

Olayın adı.

listener

(args: any[]) => void

Geri çağırma işlevi

Döndürülenler

ModuleClient

InternalClient.prependListener'dan Devralınan

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

dinleyiciler dizisinin başlayan adlı olay için tek seferlik bir işlevi ekler. eventName bir sonraki tetiklendiğinde, bu dinleyici kaldırılır ve sonra çağrılır.

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

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

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

Parametreler

eventName

string | symbol

Olayın adı.

listener

(args: any[]) => void

Geri çağırma işlevi

Döndürülenler

ModuleClient

InternalClient.prependOnceListener'dan Devralınan

rawListeners<K>(string | symbol)

tüm sarmalayıcılar (.once()tarafından oluşturulanlar gibi) dahil olmak üzere eventNameadlı olay için dinleyici dizisinin bir kopyasını döndürür.

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

Parametreler

eventName

string | symbol

Döndürülenler

Function[]

InternalClient.rawListeners'dan Devralınan

reject(Message) 

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

Parametreler

message
Message

Döndürülenler

Promise<MessageRejected>

InternalClient.reject Devralındı

reject(Message, Callback<MessageRejected>) 

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

Parametreler

message
Message
rejectCallback

Callback<MessageRejected>

InternalClient.reject Devralındı

removeAllListeners(string | symbol)

Tüm dinleyicileri veya belirtilen eventNameolanları kaldırır.

Özellikle EventEmitter örneği başka bir bileşen veya modül (örneğin yuvalar veya dosya akışları) tarafından oluşturulduğunda kodun başka bir yerine eklenen dinleyicileri kaldırmak kötü bir uygulamadır.

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

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

Parametreler

eventName

string | symbol

Döndürülenler

ModuleClient

InternalClient.removeAllListeners Devralındı

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

eventNameadlı olay için dinleyici dizisinden belirtilen listener kaldırır.

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

removeListener() dinleyici dizisinden en fazla bir dinleyici örneğini kaldırır. Belirtilen eventNameiçin dinleyici dizisine birden çok kez tek bir dinleyici eklendiyse, her örneği kaldırmak için removeListener() birden çok kez çağrılmalıdır.

Bir olay yayımlandıktan sonra, yayma sırasında ona eklenen tüm dinleyiciler sırayla çağrılır. Bu, son dinleyici yürütmeyi bitirmeden önce veya çağrısının yürütmeyi bitirmeden önce veya çağrılarının devam eden kaldırmayacağını gösterir. Sonraki olaylar beklendiği gibi davranır.

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

Dinleyiciler bir iç dizi kullanılarak yönetildiğinden, bu çağrının çağrılması, dinleyici kaldırıldıktan sonra kaydedilen tüm dinleyicilerin konum dizinlerini değiştirir. Bu, dinleyicilerin çağrılma sırasını etkilemez, ancak emitter.listeners() yöntemi tarafından döndürülen dinleyici dizisi kopyalarının yeniden oluşturulması gerektiği anlamına gelir.

Tek bir işlev tek bir olay için birden çok kez işleyici olarak eklendiğinde (aşağıdaki örnekte olduğu gibi), removeListener() en son eklenen örneği kaldırır. Örnekte once('ping') dinleyicisi kaldırılır:

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');

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

ModuleClient

InternalClient.removeListener Devralındı

sendEvent(Message) 

function sendEvent(message: Message): Promise<MessageEnqueued>

Parametreler

message
Message

Döndürülenler

Promise<MessageEnqueued>

InternalClient.sendEvent'ten Devralınan

sendEvent(Message, Callback<MessageEnqueued>) 

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parametreler

message
Message
sendEventCallback

Callback<MessageEnqueued>

InternalClient.sendEvent'ten Devralınan

sendEventBatch(Message[]) 

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parametreler

messages

Message[]

Döndürülenler

Promise<MessageEnqueued>

InternalClient.sendEventBatch Devralındı

sendEventBatch(Message[], Callback<MessageEnqueued>) 

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parametreler

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

InternalClient.sendEventBatch Devralındı

setMaxListeners(number)

Varsayılan olarak, belirli bir olay için 10'den fazla dinleyici eklenirse EventEmitterbir uyarı yazdırır. Bu, bellek sızıntılarını bulmaya yardımcı olan kullanışlı bir varsayılan değerdir. emitter.setMaxListeners() yöntemi, sınırın bu belirli EventEmitter örneği için değiştirilmesini sağlar. Değer, sınırsız sayıda dinleyiciyi göstermek için Infinity (veya 0) olarak ayarlanabilir.

Çağrıların zincirlenebilmesi için EventEmitterbir başvuru döndürür.

function setMaxListeners(n: number): ModuleClient

Parametreler

n

number

Döndürülenler

ModuleClient

InternalClient.setMaxListeners Devralındı

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

Parametreler

n

number

Negatif olmayan bir sayı. EventTarget olay başına en fazla dinleyici sayısı.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

InternalClient.setMaxListeners Devralındı

setRetryPolicy(RetryPolicy)

İstemci tarafından tüm işlemlerde kullanılan yeniden deneme ilkesini ayarlar. Varsayılan değer ExponentialBackoffWithJitter'dir.

function setRetryPolicy(policy: RetryPolicy)

Parametreler

policy

RetryPolicy

{RetryPolicy} Gelecekteki tüm işlemler için kullanılması gereken yeniden deneme ilkesi.

InternalClient.setRetryPolicy'den Devralınan

setTransportOptions(any) 

function setTransportOptions(options: any): Promise<TransportConfigured>

Parametreler

options

any

Döndürülenler

Promise<TransportConfigured>

InternalClient.setTransportOptions Devralındı

setTransportOptions(any, Callback<TransportConfigured>) 

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parametreler

options

any

done

Callback<TransportConfigured>

InternalClient.setTransportOptions Devralındı

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parametreler

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

InternalClient.updateSharedAccessSignature'dan Devralınan

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

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

Parametreler

error

Error

event

string | symbol

args

AnyRest

InternalClient.__@captureRejectionSymbol@142'dan Devralınan