Readable interface

Paket:: @azure/storage-common

Extends: Stream

Özellikler

closed	Yayımlandıktan `true` sonra `'close'` .
destroyed	Sonrasında `truereadable.destroy()` çağrıldı.
errored	Akış bir hata ile yok edildiyse hata döndürür.
readable	`true` Okuma çağrısı yapmak güvenli mi, yani akış yok edilmemiş, `'error'` yayılmamış ya `'end'`da .
readableAborted	Yayın vermeden önce akışın yok edilip edilmediğini veya hata `'end'`yapıldığını döndürür.
readableDidRead	Yayımlanıp `'data'` yayılmış olmadığını geri getirir.
readableEncoding	Belirli `encoding` bir akının özelliği `Readable` için getter. Özellik, `encoding`setEncoding yöntemiyle ayarlanabilir.
readableEnded	Olay yayıldığında `true` olur`'end'`.
readableFlowing	Bu özellik, `Readable` bölümünde tanımlanan bir akarsuyun mevcut durumunu yansıtır.
readableHighWaterMark	Bu oluşturulduğunda `highWaterMark`geçtiğin `Readable` değerini döndürür.
readableLength	Bu özellik, kuyruktaki okunmaya hazır bayt (veya nesne) sayısını içerir. Değer `highWaterMark`, .
readableObjectMode	Belirli `objectMode` bir akının özelliği `Readable` için getter.

Yöntemler

addListener(string \| symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)	Diğer ad için `emitter.on(eventName, listener)`.
compose(WritableStream \| WritableStream \| TransformStream \| (source: any) => void, Abortable)	`import { Readable } from 'node:stream'; async function* splitToWords(source) { for await (const chunk of source) { const words = String(chunk).split(' '); for (const word of words) { yield word; } } } const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords); const words = await wordsStream.toArray(); console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']` `readable.compose(s)` ile eşdeğerdir `stream.compose(readable, s)`. Bu yöntem ayrıca, kesildiğinde oluşturulan akışı yok eden bir `AbortSignal` a'nın sağlanmasına da olanak tanır. Daha fazla bilgi için bkz. `stream.compose(...streams)`.
destroy(Error)	Akışı yok edin. İstehsel olarak bir `'error'` olay yayabilir ve bir `'close'` olay yayabilir (eğer `emitClose` ayarlanmışsa `false`). Bu çağrıdan sonra, okunabilir akış tüm dahili kaynakları serbest bırakır ve sonraki çağrılar `push()` göz ardı edilir. Çağrıldıktan sonra `destroy()` herhangi bir başka çağrı no-op olur ve başka hata dışında ' `_destroy()` olarak yayımlanabilir.`'error'` Uygulayıcılar bu yöntemi geçersiz kılmamalı, bunun yerine `readable._destroy()`.
drop(number, Abortable)	Bu yöntem, başlangıçtan itibaren ilk limit chunk'ları bırakılmış yeni bir akış döndürür.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	`eventName`adlı 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
every((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Bu yöntem, `Array.prototype.every` akıştaki her parçada fn çağırarak beklenen tüm geri dönüş değerlerinin fn için doğruluk değeri olup olmadığını kontrol eder. Bir fn çağrısı bir chunk `await`ed geri dönüş değeri sahte olduğunda, akış yok edilir ve söz yerine getirilir `false`. Eğer tüm fn çağrıları chunk'ta bir doğruluk değeri döndürürse, söz ile `true`yerine getirilir.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	Bu yöntem, akışın filtrelenmesine olanak tanır. Akıştaki her parça için fn fonksiyonu çağrılır ve eğer doğruluk değeri dönerse, parça sonuç akışına iletilir. Eğer fn fonksiyonu bir vaat döndürürse - o söz ed `await`olur.
find((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)
find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Bu yöntem, `Array.prototype.find` akıştaki her chunk üzerinde fn çağırarak fn için doğruluk değeri olan bir chunk bulur. Bir fn çağrısının beklenen geri dönüş değeri doğruluk olduğunda, akış yok edilir ve vaat, fn'nin doğruluk değeri döndürdüğü değerle yerine getirilir. Eğer tüm fn çağrıları parça halte değer döndürürse, söz ile `undefined`yerine getirilir.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Bu yöntem, verilen geri dönüş dönüşünü her bir akış parçasına uygulayarak ve ardından sonucu düzleştirerek yeni bir akış döndürür. Fn'den bir akış veya başka bir iterable veya asenkron yinelenebilir geri dönüş yapmak mümkündür ve sonuç akışları geri dönen akışa birleştirilir (düzleştirilir).
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Bu yöntem, bir akışı yinelemeye olanak tanır. Akıştaki her bölüm için fn fonksiyonu çağrılacaktır. Eğer fn fonksiyonu bir vaat döndürürse - o söz ed `await`olur. Bu yöntem, `for await...of` döngülerden farklıdır; isteğe bağlı olarak parçaları eşzamanlı olarak işleyebilir. Ayrıca, bir `forEach` yineleme yalnızca bir `signal` seçeneği geçirip ilgili AbortController iptal edilerek durdurulabilir, `for await...of` ancak veya `break`ile durdurulabilir`return`. Her iki durumda da akış yok olacak. Bu yöntem, olayı dinlemekten `'data'` farklıdır; olayı `readable` temel makinede kullanır ve eşzamanlı fn çağrılarının sayısını sınırlayabilir.
isPaused()	Yöntem, `readable.isPaused()` ' `Readable`nin mevcut çalışma durumunu döndürür. Bu, öncelikle yöntemin `readable.pipe()` altında duran mekanizma tarafından kullanılır. Çoğu tipik durumda, bu yöntemi doğrudan kullanmaya gerek kalmaz. `const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false`
iterator(ReadableIteratorOptions)	Bu yöntemle oluşturulan yinelemeci, kullanıcılara döngü , `for await...of`, veya `return`, ile çıkarsa `break`akışın yok `throw` edilmesini iptal etme seçeneği sunar; ya da yineleme sırasında akış hata çıkarırsa yineleyicinin akışı yok etmesi gerekirse seçeneği vardır.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	`eventName`adlı 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(string \| symbol)
listeners<E>(E)	`eventName`adlı 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] ]`
map((data: any, options?: Abortable) => any, ReadableOperatorOptions)	Bu yöntem, akış üzerinde haritalanmasına olanak tanır. fn fonksiyonu, akıştaki her bölüm için çağrılacaktır. Eğer fn fonksiyonu bir vaat döndürürse - o söz `await`sonuç akışına iletmeden önce ed olur.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Diğer ad için `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	`listener` işlevini `eventName`adlı 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 `EventEmitter`bir 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(string \| symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)	adlı olay için tek seferlik bir `listenereventName` 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 `EventEmitter`bir 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`
pause()	Bu yöntem, `readable.pause()` akış modundaki bir akının olay yaymasını `'data'` durdurmasına ve akış modundan çıkmasına neden olur. Mevcut olan tüm veriler dahili buffer'da kalacaktır. const readable = getReadableStreamSomehow(); readable.on('data', (chunk) => { console.log(`Received ${chunk.length} bytes of data.`); readable.pause(); console.log('There will be no additional data for 1 second.'); setTimeout(() => { console.log('Now data will start flowing again.'); readable.resume(); }, 1000); }); `readable.pause()` Yöntem, bir `'readable'` olay dinleyicisi varsa hiçbir etkisi olmaz.
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => 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 `EventEmitter`bir başvuru döndürür.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => 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 `EventEmitter`bir başvuru döndürür.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	tüm sarmalayıcılar (`eventName`tarafından oluşturulanlar gibi) dahil olmak üzere `.once()`adlı 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');
read(number)	Yöntem, `readable.read()` verileri dahili tampondan okur ve geri gönderir. Okunacak veri yoksa, `null` geri gönderilir. Varsayılan olarak, veri bir nesne olarak `Buffer` döner, ancak yöntem kullanılarak `readable.setEncoding()` kodlama belirtilmedikçe veya akış nesne modunda çalışıyorsa. Isteğe `size` bağlı argüman, okunması gereken belirli bir bayt sayısını belirtir. Baytlar `size` okunamazsa, `null` akış bitmedikçe geri gönderilir; bu durumda iç tamponda kalan tüm veriler geri döner. Argüman `size` belirtilmemişse, dahili tampondaki tüm veriler geri gönderilir. Argüman `size` 1 GiB'den az veya eşit olmalıdır. Yöntem `readable.read()` yalnızca duraklatılmış modda çalışan akışlarda çağrılmalıdır `Readable` . Akış modunda, `readable.read()` iç tampon tamamen boşalana kadar otomatik olarak çağrılır. const readable = getReadableStreamSomehow(); // 'readable' may be triggered multiple times as data is buffered in readable.on('readable', () => { let chunk; console.log('Stream is readable (new data received in buffer)'); // Use a loop to make sure we read all currently available data while (null !== (chunk = readable.read())) { console.log(`Read ${chunk.length} bytes of data...`); } }); // 'end' will be triggered once when there is no more data available readable.on('end', () => { console.log('Reached end of stream.'); }); Her çağrı `readable.read()` bir veri parçası döndürür, ya `null`da . Parçalar birleşmemiştir. Şu anda tamponda bulunan tüm verileri tüketmek için bir `while` döngü gereklidir. Büyük bir dosya `.read()` okunurken, şimdiye kadar tüm tamponlu içeriği tüketmiş olabilir `null`, ancak henüz tamponlanmamış daha fazla veri var. Bu durumda, tamponda daha fazla veri olduğunda yeni `'readable'` bir olay yayımlanır. Son olarak, daha fazla veri kalmadığında etkinlik `'end'` yayınlanacak. Bu nedenle, bir dosyanın tüm içeriğini bir `readable`'dan okumak için, birden fazla `'readable'` olay boyunca parçaların toplanması gerekir: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` Nesne modundaki bir akış, `Readable` argümanın `readable.read(size)` değeri ne olursa olsun her zaman çağrıdan `size`tek bir öğe döndürür. Yöntem `readable.read()` bir veri parçası döndürürse, bir `'data'` olay da yayımlanır. Olay yayınlandıktan sonra `'end'` çağrı geri dönecektir`null`. Çalışma zamanı hatası ortaya çıkmaz.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	Bu yöntem, akışın her parçası üzerinde fn'yi sırayla çağırır ve önceki eleman üzerindeki hesaplamanın sonucunu ona iletmektedir. İndirgenimin nihai değeri için bir vaat verir. Eğer başlangıç değeri sağlanmazsa, akışın ilk parçası başlangıç değeri olarak kullanılır. Akış boşsa, vaat a ile kod `TypeError` özelliğiyle reddedilir`ERR_INVALID_ARGS`. Indirgen fonksiyonu, akışı eleman element yineleme yapar, bu da eşzamanlılık parametresi veya paralellik olmadığı anlamına gelir. Eşzamanlı bir redaksiyon yapmak için, asenkron fonksiyonu metod `readable.map` olarak çıkarabilirsiniz.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Tüm dinleyicileri veya belirtilen `eventName`olanları 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 `EventEmitter`bir başvuru döndürür.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	`listener`adlı olay için dinleyici dizisinden belirtilen `eventName` 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 `eventName`iç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, `removeListener()` herhangi bir `removeAllListeners()` yayınlandıktan sonra ve son dinleyici uygulamayı bitirmeden önce devam eden döngüden kaldırılmayacağı `emit()` anlamına gelir. 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 dahili bir diziyle yönetildiği için, bunu çağırmak, dinleyici çıkarıldıktan sonra kayıtlı herhangi bir dinleyicinin konum indekslerini 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 `EventEmitter`bir başvuru döndürür.
resume()	Bu `readable.resume()` yöntem, açıkça durakmış `Readable` bir akışın yayımlanan olayları devam `'data'` ettirmesine ve akışın akış moduna geçmesine neden olur. Bu `readable.resume()` yöntem, bir akıştan gelen verileri tam olarak tüketmek için kullanılabilir, ancak bu verileri gerçekten işlemeden kullanılabilir: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` `readable.resume()` Yöntem, bir `'readable'` olay dinleyicisi varsa hiçbir etkisi olmaz.
setEncoding(BufferEncoding)	Yöntem, `readable.setEncoding()` akıştan okunan `Readable` veri için karakter kodlamasını belirler. Varsayılan olarak, herhangi bir kodlama atanmaz ve akış verisi nesne olarak `Buffer` geri döner. Bir kodlama ayarlanması, akış verisinin nesne olarak değil `Buffer` , belirtilen kodlamanın dizileri olarak geri dönmesine neden olur. Örneğin, çağırma `readable.setEncoding('utf8')` çıktı verisi UTF-8 veri olarak yorumlanır ve dizi olarak iletilir. Çağırma `readable.setEncoding('hex')` işlemi verinin onaltılık dizi formatında kodlanmasına neden olur. Akış, `Readable` akış üzerinden iletilen çok baytlı karakterleri düzgün şekilde işliyor; aksi takdirde akıştan nesne olarak çekildiğinde yanlış çözülecek `Buffer` . `const readable = getReadableStreamSomehow(); readable.setEncoding('utf8'); readable.on('data', (chunk) => { assert.equal(typeof chunk, 'string'); console.log('Got %d characters of string data:', chunk.length); });`
some((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Bu yöntem, `Array.prototype.some` beklenen geri dönüş değeri (veya herhangi bir doğruluk değeri) olana kadar akıştaki her parçada `true` çağırır. Bir fn çağrısı bir chunk `await`ed geri dönüş değeri doğruluk olduğunda, akış yok edilir ve söz yerine getirilir `true`. Eğer fn çağrılarından hiçbiri parçalardaki gerçek değeri döndürmezse, söz ile `false`yerine getirilir.
take(number, Abortable)	Bu yöntem, ilk limit parçalarına sahip yeni bir akış döndürür.
toArray(Abortable)	Bu yöntem, bir akışın içeriğini kolayca elde etmeyi sağlar. Bu yöntem tüm akışı hafıza okuyduğundan, akışların faydalarını ortadan kaldırır. Akışları tüketmenin birincil yolu olarak değil, birlikte çalışabilirlik ve kolaylık için tasarlanmıştır.
unpipe(WritableStream)	Bu yöntem`readable.unpipe()`, boru `Writable` önceden bağlı olan bir dereyi koparır. Belirtilmemişse `destination` , tüm borular ayrılır. Eğer belirtilmişse `destination` ama bunun için bir boru kurulmamışsa, yöntem hiçbir işe yaramaz. `import fs from 'node:fs'; const readable = getReadableStreamSomehow(); const writable = fs.createWriteStream('file.txt'); // All the data from readable goes into 'file.txt', // but only for the first second. readable.pipe(writable); setTimeout(() => { console.log('Stop writing to file.txt.'); readable.unpipe(writable); console.log('Manually close the file stream.'); writable.end(); }, 1000);`
unshift(any, BufferEncoding)	Sinyal `chunknull` olarak aktarmak akışın sonunu (EOF) gösterir ve `readable.push(null)`aynı şekilde davranır, bundan sonra daha fazla veri yazılamaz. EOF sinyali tamponun sonuna yerleştirilir ve tamponlu veriler yine de silinir. Yöntem, `readable.unshift()` bir veri parçasını dahili tampona geri gönderir. Bu, bir akışın kaynak üzerinden iyimserce çektiği bir miktardaki veriyi "tüketmekten kurtarması" gereken kod tarafından tüketildiği durumlarda faydalıdır; böylece veri başka bir tarafa iletilabiliyor. `stream.unshift(chunk)` Olay yayımlandıktan sonra `'end'` yöntem çağrılamaz veya çalışma zamanı hatası atılır. Sık kullanan `stream.unshift()` geliştiriciler, bunun yerine akış `Transform` kullanımına geçmeyi düşünmeli. Daha fazla bilgi için bölüme `API for stream implementers` bakınız. // Pull off a header delimited by \n\n. // Use unshift() if we get too much. // Call the callback with (error, header, stream). import { StringDecoder } from 'node:string_decoder'; function parseHeader(stream, callback) { stream.on('error', callback); stream.on('readable', onReadable); const decoder = new StringDecoder('utf8'); let header = ''; function onReadable() { let chunk; while (null !== (chunk = stream.read())) { const str = decoder.write(chunk); if (str.includes('\n\n')) { // Found the header boundary. const split = str.split(/\n\n/); header += split.shift(); const remaining = split.join('\n\n'); const buf = Buffer.from(remaining, 'utf8'); stream.removeListener('error', callback); // Remove the 'readable' listener before unshifting. stream.removeListener('readable', onReadable); if (buf.length) stream.unshift(buf); // Now the body of the message can be read from the stream. callback(null, header, stream); return; } // Still reading the header. header += str; } } } Push'ın aksine, `stream.unshift(chunk)` akışın iç okuma durumunu sıfırlayarak okuma sürecini sonlandırmaz. Bu, okuma sırasında çağrıldığında (örneğin `readable.unshift()` uygulamasından çağrıldığında) beklenmedik sonuçlara yol açabilir. Çağrıyı `readable.unshift()` hemen itmek okuma durumunu uygun şekilde sıfırlar, ancak okuma işlemi sırasında aramaktan `readable.unshift()` kaçınmak en iyisidir.
wrap(ReadableStream)	Node.js 0.10'dan önce, akışlar modül API'sinin `node:stream` tamamını şu anda tanımlandığı şekilde uygulamamıştı. (Daha fazla bilgi için bakınız.)`Compatibility` Olay yayan `'data'` ve yalnızca danışma amaçlı duraklatma yöntemi olan eski bir Node.js kütüphanesi kullanıldığında, bu `readable.wrap()` yöntem eski akışı veri kaynağı olarak kullanan bir `Readable` akış oluşturmak için kullanılabilir. Nadiren kullanılması `readable.wrap()` gerekebilir ancak yöntem, eski Node.js uygulamaları ve kütüphanelerle etkileşim için kolaylık sağlamak amacıyla sağlanmıştır. `import { OldReader } from './old-api-module.js'; import { Readable } from 'node:stream'; const oreader = new OldReader(); const myReader = new Readable().wrap(oreader); myReader.on('readable', () => { myReader.read(); // etc. });`
[asyncDispose]()	Yayın `readable.destroy()AbortError` bittiğinde bir söz verir ve bir söz verir.
[asyncIterator]()
[toAsyncStreamable]()	Bayrak `--experimental-stream-iter` etkinleştirildiğinde, `Readable` akışlar protokolü `Stream.toAsyncStreamable` uygular ve API tarafından verimli tüketimle `stream/iter` sonuçlanır. Bu, akışın iç tamponunu partilere `Uint8Array[]` boşaltan ve standart `Symbol.asyncIterator` yolun parça başına Promise yükünü amortisan toplu bir asenkron iteratör sağlar. Bayt modlu akışlar için, parçalar doğrudan `Buffer` örnek olarak (ki bunlar `Uint8Array` alt sınıflardır) olarak elde edilir. Nesne modu veya kodlanmış akışlar için, her parça toplu önceye normalize `Uint8Array` edilir. Geri dönen yineleci doğrulanmış bir kaynak olarak etiketlenir, bu yüzden `from()` ek normalizasyon olmadan geçer. `import { Readable } from 'node:stream'; import { text, from } from 'node:stream/iter'; const readable = new Readable({ read() { this.push('hello'); this.push(null); }, }); // Readable is automatically consumed via toAsyncStreamable console.log(await text(from(readable))); // 'hello'` Bayrak olmadan, bu yöntemi çağırmak `--experimental-stream-iterERR_STREAM_ITER_MISSING_FLAG`.

Devralınan Yöntemler

eventNames()	Vericinin dinleyicileri kaydettiği olayları listeleyen bir dizi döndürür. `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) ]`
getMaxListeners()	`EventEmitter` veya varsayılan olarak `emitter.setMaxListeners(n)`olarak ayarlanan `events.defaultMaxListeners` için geçerli en yüksek dinleyici değerini döndürür.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Varsayılan olarak, belirli bir olay için `EventEmitter`'den fazla dinleyici eklenirse `10`bir 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 `EventEmitter`bir başvuru döndürür.
[captureRejectionSymbol](Error, string \| symbol, any[])	Yöntem, `Symbol.for('nodejs.rejection')` bir olay yayıldığında söz reddedilmesi durumunda çağrılır ve `captureRejections` yayıcıda etkinleştirilir. `events.captureRejectionSymbol` `Symbol.for('nodejs.rejection')`Yerine kullanılmak mümkündür. `import { EventEmitter, captureRejectionSymbol } from 'node:events'; class MyClass extends EventEmitter { constructor() { super({ captureRejections: true }); } [captureRejectionSymbol](err, event, ...args) { console.log('rejection happened for', event, 'with', err, ...args); this.destroy(err); } destroy(err) { // Tear the resource down here. } }`

Özellik Ayrıntıları

closed

Yayımlandıktan true sonra 'close' .

closed: boolean

Özellik Değeri

boolean

destroyed

Sonrasında truereadable.destroy() çağrıldı.

destroyed: boolean

Özellik Değeri

boolean

errored

Akış bir hata ile yok edildiyse hata döndürür.

errored: Error | null

Özellik Değeri

Error | null

readable

true Okuma çağrısı yapmak güvenli mi, yani akış yok edilmemiş, 'error' yayılmamış ya 'end'da .

readable: boolean

Özellik Değeri

boolean

readableAborted

Yayın vermeden önce akışın yok edilip edilmediğini veya hata 'end'yapıldığını döndürür.

readableAborted: boolean

Özellik Değeri

boolean

readableDidRead

Yayımlanıp 'data' yayılmış olmadığını geri getirir.

readableDidRead: boolean

Özellik Değeri

boolean

readableEncoding

Belirli encoding bir akının özelliği Readable için getter. Özellik, encodingsetEncoding yöntemiyle ayarlanabilir.

readableEncoding: BufferEncoding | null

Özellik Değeri

BufferEncoding | null

readableEnded

Olay yayıldığında true olur'end'.

readableEnded: boolean

Özellik Değeri

boolean

readableFlowing

Bu özellik, Readable bölümünde tanımlanan bir akarsuyun mevcut durumunu yansıtır.

readableFlowing: boolean | null

Özellik Değeri

boolean | null

readableHighWaterMark

Bu oluşturulduğunda highWaterMarkgeçtiğin Readable değerini döndürür.

readableHighWaterMark: number

Özellik Değeri

number

readableLength

Bu özellik, kuyruktaki okunmaya hazır bayt (veya nesne) sayısını içerir. Değer highWaterMark, .

readableLength: number

Özellik Değeri

number

readableObjectMode

Belirli objectMode bir akının özelliği Readable için getter.

readableObjectMode: boolean

Özellik Değeri

boolean

Yöntem Ayrıntıları

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

addListener<E>(E, (args: ReadableEventMap[E]) => void)

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

function addListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

listener: (args: ReadableEventMap[E]) => void

Döndürülenler

this

compose(WritableStream | WritableStream | TransformStream | (source: any) => void, Abortable)

import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']

readable.compose(s) ile eşdeğerdir stream.compose(readable, s).

Bu yöntem ayrıca, kesildiğinde oluşturulan akışı yok eden bir AbortSignal a'nın sağlanmasına da olanak tanır.

Daha fazla bilgi için bkz. stream.compose(...streams).

function compose(stream: WritableStream | WritableStream | TransformStream | (source: any) => void, options?: Abortable): Duplex

Parametreler

stream: WritableStream | WritableStream | TransformStream | (source: any) => void

options: Abortable

Döndürülenler

Duplex

bir akıntı ile streamoluşturulan bir akış.

destroy(Error)

Akışı yok edin. İstehsel olarak bir 'error' olay yayabilir ve bir 'close' olay yayabilir (eğer emitClose ayarlanmışsa false). Bu çağrıdan sonra, okunabilir akış tüm dahili kaynakları serbest bırakır ve sonraki çağrılar push() göz ardı edilir.

Çağrıldıktan sonra destroy() herhangi bir başka çağrı no-op olur ve başka hata dışında ' _destroy() olarak yayımlanabilir.'error'

Uygulayıcılar bu yöntemi geçersiz kılmamalı, bunun yerine readable._destroy().

function destroy(error?: Error): this

Parametreler

error: Error

Hata ve olayda 'error' yük olarak iletilir

Döndürülenler

this

drop(number, Abortable)

Bu yöntem, başlangıçtan itibaren ilk limit chunk'ları bırakılmış yeni bir akış döndürür.

function drop(limit: number, options?: Abortable): Readable

Parametreler

limit: number

okunabilir bölümden düşecek parça sayısı.

options: Abortable

Döndürülenler

Readable

Baştan limitli bölümlerin bırakıldığı bir akış.

emit(string | symbol, any[])

function emit(eventName: string | symbol, args: any[]): boolean

Parametreler

eventName: string | symbol

args: any[]

Döndürülenler

boolean

emit<E>(E, ReadableEventMap[E])

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<E>(eventName: E, args: ReadableEventMap[E]): boolean

Parametreler

eventName: E

args: ReadableEventMap[E]

Döndürülenler

boolean

every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Bu yöntem, Array.prototype.every akıştaki her parçada fn çağırarak beklenen tüm geri dönüş değerlerinin fn için doğruluk değeri olup olmadığını kontrol eder. Bir fn çağrısı bir chunk awaited geri dönüş değeri sahte olduğunda, akış yok edilir ve söz yerine getirilir false. Eğer tüm fn çağrıları chunk'ta bir doğruluk değeri döndürürse, söz ile trueyerine getirilir.

function every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

Parametreler

fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

akışın her parçasını çağıran bir fonksiyon. Asenkron olsun ya da olmasın.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Promise<boolean>

Her bir parça true doğruluk değeri verip vermediğini değerlendiren bir vaat.

filter((data: any, options?: Abortable) => boolean | Promise<boolean>, ReadableOperatorOptions)

Bu yöntem, akışın filtrelenmesine olanak tanır. Akıştaki her parça için fn fonksiyonu çağrılır ve eğer doğruluk değeri dönerse, parça sonuç akışına iletilir. Eğer fn fonksiyonu bir vaat döndürürse - o söz ed awaitolur.

function filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable

Parametreler

fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

akıştan parçaları filtreleyen bir fonksiyon. Asenkron olsun ya da olmasın.

options: ReadableOperatorOptions

Döndürülenler

Readable

fn yüklemiyle filtrelenmiş bir akış.

find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

function find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>

Parametreler

fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Promise<any>

find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Bu yöntem, Array.prototype.find akıştaki her chunk üzerinde fn çağırarak fn için doğruluk değeri olan bir chunk bulur. Bir fn çağrısının beklenen geri dönüş değeri doğruluk olduğunda, akış yok edilir ve vaat, fn'nin doğruluk değeri döndürdüğü değerle yerine getirilir. Eğer tüm fn çağrıları parça halte değer döndürürse, söz ile undefinedyerine getirilir.

function find<T>(fn: (data: any, options?: Abortable) => data is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>

Parametreler

fn: (data: any, options?: Abortable) => data is T

akışın her parçasını çağıran bir fonksiyon. Asenkron olsun ya da olmasın.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Promise<T | undefined>

Fn'nin doğruluk değeriyle değerlendirdiği ya undefined da herhangi bir element bulunmadığı ilk parçaya değer verilmesi vaat edilirdi.

flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Bu yöntem, verilen geri dönüş dönüşünü her bir akış parçasına uygulayarak ve ardından sonucu düzleştirerek yeni bir akış döndürür.

Fn'den bir akış veya başka bir iterable veya asenkron yinelenebilir geri dönüş yapmak mümkündür ve sonuç akışları geri dönen akışa birleştirilir (düzleştirilir).

function flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Readable

Parametreler

fn: (data: any, options?: Abortable) => any

akıştaki her bölümü haritalayan bir fonksiyon. Belki de asenkron. Bir akarsu veya jeneratör olabilir.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Readable

fn fonksiyonuyla düz eşlenmiş bir akış.

forEach((data: any, options?: Abortable) => void | Promise<void>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Bu yöntem, bir akışı yinelemeye olanak tanır. Akıştaki her bölüm için fn fonksiyonu çağrılacaktır. Eğer fn fonksiyonu bir vaat döndürürse - o söz ed awaitolur.

Bu yöntem, for await...of döngülerden farklıdır; isteğe bağlı olarak parçaları eşzamanlı olarak işleyebilir. Ayrıca, bir forEach yineleme yalnızca bir signal seçeneği geçirip ilgili AbortController iptal edilerek durdurulabilir, for await...of ancak veya breakile durdurulabilirreturn. Her iki durumda da akış yok olacak.

Bu yöntem, olayı dinlemekten 'data' farklıdır; olayı readable temel makinede kullanır ve eşzamanlı fn çağrılarının sayısını sınırlayabilir.

function forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>

Parametreler

fn: (data: any, options?: Abortable) => void | Promise<void>

akışın her parçasını çağıran bir fonksiyon. Asenkron olsun ya da olmasın.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Promise<void>

yayın bittiğinde vereceği bir söz.

isPaused()

Yöntem, readable.isPaused() ' Readablenin mevcut çalışma durumunu döndürür. Bu, öncelikle yöntemin readable.pipe() altında duran mekanizma tarafından kullanılır. Çoğu tipik durumda, bu yöntemi doğrudan kullanmaya gerek kalmaz.

const readable = new stream.Readable();

readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false

function isPaused(): boolean

Döndürülenler

boolean

iterator(ReadableIteratorOptions)

Bu yöntemle oluşturulan yinelemeci, kullanıcılara döngü , for await...of, veya return, ile çıkarsa breakakışın yok throw edilmesini iptal etme seçeneği sunar; ya da yineleme sırasında akış hata çıkarırsa yineleyicinin akışı yok etmesi gerekirse seçeneği vardır.

function iterator(options?: ReadableIteratorOptions): AsyncIterator<any>

Parametreler

options: ReadableIteratorOptions

Döndürülenler

AsyncIterator<any>

listenerCount(string | symbol, (args: any[]) => void)

function listenerCount(eventName: string | symbol, listener?: (args: any[]) => void): number

Parametreler

eventName: string | symbol

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

Döndürülenler

number

listenerCount<E>(E, (args: ReadableEventMap[E]) => void)

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<E>(eventName: E, listener?: (args: ReadableEventMap[E]) => void): number

Parametreler

eventName: E

Dinlenen olayın adı

listener: (args: ReadableEventMap[E]) => void

Olay işleyici işlevi

Döndürülenler

number

listeners(string | symbol)

function listeners(eventName: string | symbol): (args: any[]) => void[]

Parametreler

eventName: string | symbol

Döndürülenler

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

listeners<E>(E)

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<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parametreler

eventName: E

Döndürülenler

(args: ReadableEventMap[E]) => void[]

map((data: any, options?: Abortable) => any, ReadableOperatorOptions)

Bu yöntem, akış üzerinde haritalanmasına olanak tanır. fn fonksiyonu, akıştaki her bölüm için çağrılacaktır. Eğer fn fonksiyonu bir vaat döndürürse - o söz awaitsonuç akışına iletmeden önce ed olur.

function map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable

Parametreler

fn: (data: any, options?: Abortable) => any

akıştaki her bölümü haritalayan bir fonksiyon. Asenkron olsun ya da olmasın.

options: ReadableOperatorOptions

Döndürülenler

Readable

fn fonksiyonuyla eşlenmiş bir akış.

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

off<E>(E, (args: ReadableEventMap[E]) => void)

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

function off<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

listener: (args: ReadableEventMap[E]) => void

Döndürülenler

this

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

on<E>(E, (args: ReadableEventMap[E]) => 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<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

Olayın adı.

listener: (args: ReadableEventMap[E]) => void

Geri çağırma işlevi

Döndürülenler

this

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

once<E>(E, (args: ReadableEventMap[E]) => void)

adlı olay için tek seferlik bir listenereventName 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<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

Olayın adı.

listener: (args: ReadableEventMap[E]) => void

Geri çağırma işlevi

Döndürülenler

this

pause()

Bu yöntem, readable.pause() akış modundaki bir akının olay yaymasını 'data' durdurmasına ve akış modundan çıkmasına neden olur. Mevcut olan tüm veriler dahili buffer'da kalacaktır.

const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes of data.`);
  readable.pause();
  console.log('There will be no additional data for 1 second.');
  setTimeout(() => {
    console.log('Now data will start flowing again.');
    readable.resume();
  }, 1000);
});

readable.pause() Yöntem, bir 'readable' olay dinleyicisi varsa hiçbir etkisi olmaz.

function pause(): this

Döndürülenler

this

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

prependListener<E>(E, (args: ReadableEventMap[E]) => 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<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

Olayın adı.

listener: (args: ReadableEventMap[E]) => void

Geri çağırma işlevi

Döndürülenler

this

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

prependOnceListener<E>(E, (args: ReadableEventMap[E]) => 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<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

Olayın adı.

listener: (args: ReadableEventMap[E]) => void

Geri çağırma işlevi

Döndürülenler

this

push(any, BufferEncoding)

function push(chunk: any, encoding?: BufferEncoding): boolean

Parametreler

chunk: any

encoding: BufferEncoding

Döndürülenler

boolean

rawListeners(string | symbol)

function rawListeners(eventName: string | symbol): (args: any[]) => void[]

Parametreler

eventName: string | symbol

Döndürülenler

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

rawListeners<E>(E)

tüm sarmalayıcılar (eventNametarafından oluşturulanlar gibi) dahil olmak üzere .once()adlı 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<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parametreler

eventName: E

Döndürülenler

(args: ReadableEventMap[E]) => void[]

read(number)

Yöntem, readable.read() verileri dahili tampondan okur ve geri gönderir. Okunacak veri yoksa, null geri gönderilir. Varsayılan olarak, veri bir nesne olarak Buffer döner, ancak yöntem kullanılarak readable.setEncoding() kodlama belirtilmedikçe veya akış nesne modunda çalışıyorsa.

Isteğe size bağlı argüman, okunması gereken belirli bir bayt sayısını belirtir. Baytlar size okunamazsa, null akış bitmedikçe geri gönderilir; bu durumda iç tamponda kalan tüm veriler geri döner.

Argüman size belirtilmemişse, dahili tampondaki tüm veriler geri gönderilir.

Argüman size 1 GiB'den az veya eşit olmalıdır.

Yöntem readable.read() yalnızca duraklatılmış modda çalışan akışlarda çağrılmalıdır Readable . Akış modunda, readable.read() iç tampon tamamen boşalana kadar otomatik olarak çağrılır.

const readable = getReadableStreamSomehow();

// 'readable' may be triggered multiple times as data is buffered in
readable.on('readable', () => {
  let chunk;
  console.log('Stream is readable (new data received in buffer)');
  // Use a loop to make sure we read all currently available data
  while (null !== (chunk = readable.read())) {
    console.log(`Read ${chunk.length} bytes of data...`);
  }
});

// 'end' will be triggered once when there is no more data available
readable.on('end', () => {
  console.log('Reached end of stream.');
});

Her çağrı readable.read() bir veri parçası döndürür, ya nullda . Parçalar birleşmemiştir. Şu anda tamponda bulunan tüm verileri tüketmek için bir while döngü gereklidir. Büyük bir dosya .read() okunurken, şimdiye kadar tüm tamponlu içeriği tüketmiş olabilir null, ancak henüz tamponlanmamış daha fazla veri var. Bu durumda, tamponda daha fazla veri olduğunda yeni 'readable' bir olay yayımlanır. Son olarak, daha fazla veri kalmadığında etkinlik 'end' yayınlanacak.

Bu nedenle, bir dosyanın tüm içeriğini bir readable'dan okumak için, birden fazla 'readable' olay boyunca parçaların toplanması gerekir:

const chunks = [];

readable.on('readable', () => {
  let chunk;
  while (null !== (chunk = readable.read())) {
    chunks.push(chunk);
  }
});

readable.on('end', () => {
  const content = chunks.join('');
});

Nesne modundaki bir akış, Readable argümanın readable.read(size) değeri ne olursa olsun her zaman çağrıdan sizetek bir öğe döndürür.

Yöntem readable.read() bir veri parçası döndürürse, bir 'data' olay da yayımlanır.

Olay yayınlandıktan sonra 'end' çağrı geri dönecektirnull. Çalışma zamanı hatası ortaya çıkmaz.

function read(size?: number): any

Parametreler

size: number

Ne kadar veri okunacağını belirtmek için isteğe bağlı argüman.

Döndürülenler

any

reduce<T>((previous: any, data: any, options?: Abortable) => T)

Bu yöntem, akışın her parçası üzerinde fn'yi sırayla çağırır ve önceki eleman üzerindeki hesaplamanın sonucunu ona iletmektedir. İndirgenimin nihai değeri için bir vaat verir.

Eğer başlangıç değeri sağlanmazsa, akışın ilk parçası başlangıç değeri olarak kullanılır. Akış boşsa, vaat a ile kod TypeError özelliğiyle reddedilirERR_INVALID_ARGS.

Indirgen fonksiyonu, akışı eleman element yineleme yapar, bu da eşzamanlılık parametresi veya paralellik olmadığı anlamına gelir. Eşzamanlı bir redaksiyon yapmak için, asenkron fonksiyonu metod readable.map olarak çıkarabilirsiniz.

function reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>

Parametreler

fn: (previous: any, data: any, options?: Abortable) => T

akıştaki her bölümü çağıran bir indirgen fonksiyonu. Asenkron olsun ya da olmasın.

Döndürülenler

Promise<T>

indirgenin nihai değeri için bir vaat.

reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)

function reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>

Parametreler

fn: (previous: T, data: any, options?: Abortable) => T

initial: T

options: Abortable

Döndürülenler

Promise<T>

removeAllListeners(string | symbol)

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

Parametreler

eventName: string | symbol

Döndürülenler

this

removeAllListeners<E>(E)

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<E>(eventName?: E): this

Parametreler

eventName: E

Döndürülenler

this

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

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

Parametreler

eventName: string | symbol

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

Döndürülenler

this

removeListener<E>(E, (args: ReadableEventMap[E]) => void)

listeneradlı olay için dinleyici dizisinden belirtilen eventName 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, removeListener() herhangi bir removeAllListeners() yayınlandıktan sonra ve son dinleyici uygulamayı bitirmeden önce devam eden döngüden kaldırılmayacağı emit() anlamına gelir. 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 dahili bir diziyle yönetildiği için, bunu çağırmak, dinleyici çıkarıldıktan sonra kayıtlı herhangi bir dinleyicinin konum indekslerini 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<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parametreler

eventName: E

listener: (args: ReadableEventMap[E]) => void

Döndürülenler

this

resume()

Bu readable.resume() yöntem, açıkça durakmış Readable bir akışın yayımlanan olayları devam 'data' ettirmesine ve akışın akış moduna geçmesine neden olur.

Bu readable.resume() yöntem, bir akıştan gelen verileri tam olarak tüketmek için kullanılabilir, ancak bu verileri gerçekten işlemeden kullanılabilir:

getReadableStreamSomehow()
  .resume()
  .on('end', () => {
    console.log('Reached the end, but did not read anything.');
  });

readable.resume() Yöntem, bir 'readable' olay dinleyicisi varsa hiçbir etkisi olmaz.

function resume(): this

Döndürülenler

this

setEncoding(BufferEncoding)

Yöntem, readable.setEncoding() akıştan okunan Readable veri için karakter kodlamasını belirler.

Varsayılan olarak, herhangi bir kodlama atanmaz ve akış verisi nesne olarak Buffer geri döner. Bir kodlama ayarlanması, akış verisinin nesne olarak değil Buffer , belirtilen kodlamanın dizileri olarak geri dönmesine neden olur. Örneğin, çağırma readable.setEncoding('utf8') çıktı verisi UTF-8 veri olarak yorumlanır ve dizi olarak iletilir. Çağırma readable.setEncoding('hex') işlemi verinin onaltılık dizi formatında kodlanmasına neden olur.

Akış, Readable akış üzerinden iletilen çok baytlı karakterleri düzgün şekilde işliyor; aksi takdirde akıştan nesne olarak çekildiğinde yanlış çözülecek Buffer .

const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
  assert.equal(typeof chunk, 'string');
  console.log('Got %d characters of string data:', chunk.length);
});

function setEncoding(encoding: BufferEncoding): this

Parametreler

encoding: BufferEncoding

Kullanılacak kodlama.

Döndürülenler

this

some((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" | "signal">)

Bu yöntem, Array.prototype.some beklenen geri dönüş değeri (veya herhangi bir doğruluk değeri) olana kadar akıştaki her parçada true çağırır. Bir fn çağrısı bir chunk awaited geri dönüş değeri doğruluk olduğunda, akış yok edilir ve söz yerine getirilir true. Eğer fn çağrılarından hiçbiri parçalardaki gerçek değeri döndürmezse, söz ile falseyerine getirilir.

function some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

Parametreler

fn: (data: any, options?: Abortable) => boolean | Promise<boolean>

akışın her parçasını çağıran bir fonksiyon. Asenkron olsun ya da olmasın.

options: Pick<ReadableOperatorOptions, "concurrency" | "signal">

Döndürülenler

Promise<boolean>

En az bir parça için true doğruluk değeri döndürüp vermediğini değerlendiren bir vaat.

take(number, Abortable)

Bu yöntem, ilk limit parçalarına sahip yeni bir akış döndürür.

function take(limit: number, options?: Abortable): Readable

Parametreler

limit: number

okunabilir alandan alınacak parça sayısı.

options: Abortable

Döndürülenler

Readable

Limitli parçalar alınan bir akış.

toArray(Abortable)

Bu yöntem, bir akışın içeriğini kolayca elde etmeyi sağlar.

Bu yöntem tüm akışı hafıza okuyduğundan, akışların faydalarını ortadan kaldırır. Akışları tüketmenin birincil yolu olarak değil, birlikte çalışabilirlik ve kolaylık için tasarlanmıştır.

function toArray(options?: Abortable): Promise<any[]>

Parametreler

options: Abortable

Döndürülenler

Promise<any[]>

akışın içeriğiyle bir dizi içeren bir vaat.

unpipe(WritableStream)

Bu yöntemreadable.unpipe(), boru Writable önceden bağlı olan bir dereyi koparır.

Belirtilmemişse destination , tüm borular ayrılır.

Eğer belirtilmişse destination ama bunun için bir boru kurulmamışsa, yöntem hiçbir işe yaramaz.

import fs from 'node:fs';
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
  console.log('Stop writing to file.txt.');
  readable.unpipe(writable);
  console.log('Manually close the file stream.');
  writable.end();
}, 1000);

function unpipe(destination?: WritableStream): this

Parametreler

destination: WritableStream

Isteğe bağlı özel bir akış açılır

Döndürülenler

this

unshift(any, BufferEncoding)

Sinyal chunknull olarak aktarmak akışın sonunu (EOF) gösterir ve readable.push(null)aynı şekilde davranır, bundan sonra daha fazla veri yazılamaz. EOF sinyali tamponun sonuna yerleştirilir ve tamponlu veriler yine de silinir.

Yöntem, readable.unshift() bir veri parçasını dahili tampona geri gönderir. Bu, bir akışın kaynak üzerinden iyimserce çektiği bir miktardaki veriyi "tüketmekten kurtarması" gereken kod tarafından tüketildiği durumlarda faydalıdır; böylece veri başka bir tarafa iletilabiliyor.

stream.unshift(chunk) Olay yayımlandıktan sonra 'end' yöntem çağrılamaz veya çalışma zamanı hatası atılır.

Sık kullanan stream.unshift() geliştiriciler, bunun yerine akış Transform kullanımına geçmeyi düşünmeli. Daha fazla bilgi için bölüme API for stream implementers bakınız.

// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
import { StringDecoder } from 'node:string_decoder';
function parseHeader(stream, callback) {
  stream.on('error', callback);
  stream.on('readable', onReadable);
  const decoder = new StringDecoder('utf8');
  let header = '';
  function onReadable() {
    let chunk;
    while (null !== (chunk = stream.read())) {
      const str = decoder.write(chunk);
      if (str.includes('\n\n')) {
        // Found the header boundary.
        const split = str.split(/\n\n/);
        header += split.shift();
        const remaining = split.join('\n\n');
        const buf = Buffer.from(remaining, 'utf8');
        stream.removeListener('error', callback);
        // Remove the 'readable' listener before unshifting.
        stream.removeListener('readable', onReadable);
        if (buf.length)
          stream.unshift(buf);
        // Now the body of the message can be read from the stream.
        callback(null, header, stream);
        return;
      }
      // Still reading the header.
      header += str;
    }
  }
}

Push'ın aksine, stream.unshift(chunk) akışın iç okuma durumunu sıfırlayarak okuma sürecini sonlandırmaz. Bu, okuma sırasında çağrıldığında (örneğin readable.unshift() uygulamasından çağrıldığında) beklenmedik sonuçlara yol açabilir. Çağrıyı readable.unshift() hemen itmek okuma durumunu uygun şekilde sıfırlar, ancak okuma işlemi sırasında aramaktan readable.unshift() kaçınmak en iyisidir.

function unshift(chunk: any, encoding?: BufferEncoding)

Parametreler

chunk: any

Okuma kuyruğuna kaydetmek için veri parçası. Nesne modunda çalışmayan akışlar için, chunk {string}, {Buffer}, {TypedArray}, {DataView} veya null. Nesne modu akışları için, chunk herhangi bir JavaScript değeri olabilir.

encoding: BufferEncoding

Dizi parçalarının kodlanması. Geçerli Buffer bir kodlama olmalıdır, örneğin 'utf8' veya 'ascii'.

wrap(ReadableStream)

Node.js 0.10'dan önce, akışlar modül API'sinin node:stream tamamını şu anda tanımlandığı şekilde uygulamamıştı. (Daha fazla bilgi için bakınız.)Compatibility

Olay yayan 'data' ve yalnızca danışma amaçlı duraklatma yöntemi olan eski bir Node.js kütüphanesi kullanıldığında, bu readable.wrap() yöntem eski akışı veri kaynağı olarak kullanan bir Readable akış oluşturmak için kullanılabilir.

Nadiren kullanılması readable.wrap() gerekebilir ancak yöntem, eski Node.js uygulamaları ve kütüphanelerle etkileşim için kolaylık sağlamak amacıyla sağlanmıştır.

import { OldReader } from './old-api-module.js';
import { Readable } from 'node:stream';
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);

myReader.on('readable', () => {
  myReader.read(); // etc.
});

function wrap(stream: ReadableStream): this

Parametreler

stream: ReadableStream

"Eski tarz" okunabilir bir akış

Döndürülenler

this

[asyncDispose]()

Yayın readable.destroy()AbortError bittiğinde bir söz verir ve bir söz verir.

function [asyncDispose](): Promise<void>

Döndürülenler

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Döndürülenler

AsyncIterator<any>

AsyncIterator Akışı tamamen tüketmek.

[toAsyncStreamable]()

Bayrak --experimental-stream-iter etkinleştirildiğinde, Readable akışlar protokolü Stream.toAsyncStreamable uygular ve API tarafından verimli tüketimle stream/iter sonuçlanır.

Bu, akışın iç tamponunu partilere Uint8Array[] boşaltan ve standart Symbol.asyncIterator yolun parça başına Promise yükünü amortisan toplu bir asenkron iteratör sağlar. Bayt modlu akışlar için, parçalar doğrudan Buffer örnek olarak (ki bunlar Uint8Array alt sınıflardır) olarak elde edilir. Nesne modu veya kodlanmış akışlar için, her parça toplu önceye normalize Uint8Array edilir.

Geri dönen yineleci doğrulanmış bir kaynak olarak etiketlenir, bu yüzden from() ek normalizasyon olmadan geçer.

import { Readable } from 'node:stream';
import { text, from } from 'node:stream/iter';

const readable = new Readable({
  read() { this.push('hello'); this.push(null); },
});

// Readable is automatically consumed via toAsyncStreamable
console.log(await text(from(readable))); // 'hello'

Bayrak olmadan, bu yöntemi çağırmak --experimental-stream-iterERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Döndürülenler

ByteReadableStream

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

eventNames()

Vericinin dinleyicileri kaydettiği olayları listeleyen bir dizi döndürür.

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

Miras Olarak Stream.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Döndürülenler

number

Miras Olarak Stream.getMaxListeners

pipe<T>(T, PipeOptions)

function pipe<T>(destination: T, options?: PipeOptions): T

Parametreler

destination: T

options: PipeOptions

Döndürülenler

Miras Olarak Stream.pipe

setMaxListeners(number)

Varsayılan olarak, belirli bir olay için EventEmitter'den fazla dinleyici eklenirse 10bir 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): this

Parametreler

n: number

Döndürülenler

this

Miras Olarak Stream.setMaxListeners

[captureRejectionSymbol](Error, string | symbol, any[])

Yöntem, Symbol.for('nodejs.rejection') bir olay yayıldığında söz reddedilmesi durumunda çağrılır ve captureRejections yayıcıda etkinleştirilir. events.captureRejectionSymbol Symbol.for('nodejs.rejection')Yerine kullanılmak mümkündür.

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parametreler

error: Error

event: string | symbol

args: any[]

Miras Alınan Akış. [captureReddedilmeSembolü]