Readable class

Paket:
@azure/storage-common
Extends

Stream

Oluşturucular

Readable(ReadableOptions<Readable>)

Ö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 Readable bir akının özelliği encoding için getter. Özellik, encodingsetEncoding yöntemiyle ayarlanabilir.
readableEnded

Olay yayıldığında 'end' olurtrue.
readableFlowing

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

Bu oluşturulduğunda Readablegeçtiğin highWaterMark 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 Readable bir akının özelliği objectMode için getter.

Yöntemler

addListener(string | symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)
compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (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])
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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.
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.
find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)
find<T>((data: any, options?: Abortable) => data, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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, "signal" | "concurrency">)

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 returnile durdurulabilirbreak. 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.
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Yinelemelerden Okunabilir Akışlar oluşturmak için bir yardımcı yöntem.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Bir web ReadableStreamüzerinden bir Readable a'yı oluşturmak için bir yardımcı yöntem.
isDisturbed(ReadableStream<any> | ReadableStream)

Yayının okunduğunu ya da iptal edildiğini geri döner.
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
iterator(ReadableIteratorOptions)

Bu yöntemle oluşturulan yinelemeci, kullanıcılara döngü , break, veya throw, ile çıkarsa returnakışın yok for await...of 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)
listeners(string | symbol)
listeners<E>(E)
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.
off(string | symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)
on(string | symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)
once(string | symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)
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)
prependOnceListener(string | symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)
push(any, BufferEncoding)
rawListeners(string | symbol)
rawListeners<E>(E)
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 size değeri ne olursa olsun her zaman çağrıdan readable.read(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'okunan çağrı geri dönecektirnull. Ç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 ERR_INVALID_ARGS özelliğiyle reddedilirTypeError.

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)
removeListener(string | symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)
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, "signal" | "concurrency">)

Bu yöntem, Array.prototype.some beklenen geri dönüş değeri true (veya herhangi bir doğruluk değeri) olana kadar akıştaki her parçada fn ç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.
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.
toWeb(ReadableStream, ReadableToWebOptions)

Bir Readable'den bir web ReadableStream oluşturmak için bir yardımcı yöntem.
unpipe(WritableStream)

Bu yöntemreadable.unpipe(), boru yöntemiyle önceden bağlı olan bir Writable 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 özel bir akışta _read uygulamasından çağrıldığında) beklenmedik sonuçlara readable.unshift() 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.
});
[asyncIterator]()

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 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.
[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.
  }
}

Oluşturucu Ayrıntıları

Readable(ReadableOptions<Readable>) 

new Readable(options?: ReadableOptions<Readable>)

Parametreler

options

ReadableOptions<Readable>

Ö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: null | Error

Özellik Değeri

null | Error

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 Readable bir akının özelliği encoding için getter. Özellik, encodingsetEncoding yöntemiyle ayarlanabilir.

readableEncoding: null | BufferEncoding

Özellik Değeri

null | BufferEncoding

readableEnded

Olay yayıldığında 'end' olurtrue.

readableEnded: boolean

Özellik Değeri

boolean

readableFlowing

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

readableFlowing: null | boolean

Özellik Değeri

null | boolean

readableHighWaterMark

Bu oluşturulduğunda Readablegeçtiğin highWaterMark 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 Readable bir akının özelliği objectMode 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): Readable

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (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<any> | TransformStream<any, any> | (source: any) => void, options?: Abortable): Duplex

Parametreler

stream

WritableStream | WritableStream<any> | TransformStream<any, any> | (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): Readable

Parametreler

error

Error

Hata ve olayda 'error' yük olarak iletilir

Döndürülenler

Readable

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

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, "signal" | "concurrency">)

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, "signal" | "concurrency">): 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, "signal" | "concurrency">

Döndürülenler

Promise<boolean>

Her bir parça için FN'nin doğruluk değeri verip vermediğini değerlendiren true 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, "signal" | "concurrency">) 

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

Parametreler

fn

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

options

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

Döndürülenler

Promise<any>

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

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, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<undefined | T>

Parametreler

fn

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

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

options

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

Döndürülenler

Promise<undefined | T>

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, "signal" | "concurrency">)

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, "signal" | "concurrency">): 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, "signal" | "concurrency">

Döndürülenler

Readable

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

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

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 returnile durdurulabilirbreak. 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, "signal" | "concurrency">): 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, "signal" | "concurrency">

Döndürülenler

Promise<void>

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

from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Yinelemelerden Okunabilir Akışlar oluşturmak için bir yardımcı yöntem.

static function from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions<Readable>): Readable

Parametreler

iterable

Iterable<any> | AsyncIterable<any>

Nesne, Symbol.iterator veya Symbol.asyncIterator tekrarlanabilir protokolü uygulayan bir sistem. Null değer geçirilirse 'hata' olayı yayılır.

options

ReadableOptions<Readable>

Seçenekler sunuldu.new stream.Readable([options]) Varsayılan olarak, Readable.from() bu açıkça reddedilmedikçe options.objectModefalse, olarak ayarlanırtrue.options.objectMode

Döndürülenler

Readable

fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Bir web ReadableStreamüzerinden bir Readable a'yı oluşturmak için bir yardımcı yöntem.

static function fromWeb(readableStream: ReadableStream<any>, options?: Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">): Readable

Parametreler

readableStream

ReadableStream<any>

options

Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">

Döndürülenler

Readable

isDisturbed(ReadableStream<any> | ReadableStream)

Yayının okunduğunu ya da iptal edildiğini geri döner.

static function isDisturbed(stream: ReadableStream<any> | ReadableStream): boolean

Parametreler

stream

ReadableStream<any> | ReadableStream

Döndürülenler

boolean

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ü , break, veya throw, ile çıkarsa returnakışın yok for await...of 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, undefined, any>

Parametreler

options

ReadableIteratorOptions

Döndürülenler

AsyncIterator<any, undefined, 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) 

function listenerCount<E>(eventName: E, listener?: (args: ReadableEventMap[E]) => void): number

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

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) 

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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

Döndürülenler

Readable

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

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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) 

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 size değeri ne olursa olsun her zaman çağrıdan readable.read(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'okunan ç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 ERR_INVALID_ARGS özelliğiyle reddedilirTypeError.

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

Parametreler

eventName

string | symbol

Döndürülenler

Readable

removeAllListeners<E>(E) 

function removeAllListeners<E>(eventName?: E): Readable

Parametreler

eventName

E

Döndürülenler

Readable

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

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

Parametreler

eventName

string | symbol

listener

(args: any[]) => void

Döndürülenler

Readable

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

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

Parametreler

eventName

E

listener

(args: ReadableEventMap[E]) => void

Döndürülenler

Readable

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

Döndürülenler

Readable

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

Parametreler

encoding

BufferEncoding

Kullanılacak kodlama.

Döndürülenler

Readable

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

Bu yöntem, Array.prototype.some beklenen geri dönüş değeri true (veya herhangi bir doğruluk değeri) olana kadar akıştaki her parçada fn ç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, "signal" | "concurrency">): 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, "signal" | "concurrency">

Döndürülenler

Promise<boolean>

En az bir parça için FN'nin doğruluk değeri döndürüp vermediğini değerlendiren true 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.

toWeb(ReadableStream, ReadableToWebOptions)

Bir Readable'den bir web ReadableStream oluşturmak için bir yardımcı yöntem.

static function toWeb(streamReadable: ReadableStream, options?: ReadableToWebOptions): ReadableStream<any>

Parametreler

streamReadable

ReadableStream

options

ReadableToWebOptions

Döndürülenler

ReadableStream<any>

unpipe(WritableStream)

Bu yöntemreadable.unpipe(), boru yöntemiyle önceden bağlı olan bir Writable 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): Readable

Parametreler

destination

WritableStream

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

Döndürülenler

Readable

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 özel bir akışta _read uygulamasından çağrıldığında) beklenmedik sonuçlara readable.unshift() 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): Readable

Parametreler

stream

ReadableStream

"Eski tarz" okunabilir bir akış

Döndürülenler

Readable

[asyncIterator]() 

function [asyncIterator](): AsyncIterator<any, undefined, any>

Döndürülenler

AsyncIterator<any, undefined, any>

AsyncIterator Akışı tamamen tüketmek.

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

T

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

Parametreler

n

number

Döndürülenler

Readable

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 Olarak Stream.__@captureRejectionSymbol@175