Readable class

패키지:

@azure/storage-common

Extends

Stream

생성자

Readable(ReadableOptions<Readable>)

속성

closed	true 방출된 이후 'close' 의 신호입니다.
destroyed	true 그 이후 readable.destroy() 에야 호출되었습니다.
errored	스트림이 오류가 발생하면 오류를 반환합니다.
readable	는 trueread를 호출해도 안전한지, 즉 스트림이 파괴되거나 방출 'error' 되지 않았다는 의미입니다.'end'
readableAborted	스트림이 방출되기 전에 'end'파괴되었거나 오류가 발생했는지 반환합니다.
readableDidRead	방출되었는지 여부 'data' 에 대해 반환합니다.
readableEncoding	주어진 encoding 스트림의 속성 Readable 에 대한 게터입니다. 이 속성은 encodingsetEncoding 메서드를 사용하여 설정할 수 있습니다.
readableEnded	이벤트가 방출될 때 true 가 됩니다'end'.
readableFlowing	이 특성은 Readable 섹션에서 설명된 하천의 현재 상태를 반영합니다.
readableHighWaterMark	이 를 highWaterMark생성할 때 전달된 값을 Readable 반환합니다.
readableLength	이 속성은 읽을 준비가 된 큐 내 바이트(또는 객체)의 수를 포함합니다. 이 값 highWaterMark은 .
readableObjectMode	주어진 objectMode 스트림의 속성 Readable 에 대한 게터입니다.

상속된 속성

captureRejections	값: 불리언 모든 새 EventEmitter 객체의 기본 captureRejections 옵션을 변경하세요.
captureRejectionSymbol	값: Symbol.for('nodejs.rejection') 맞춤 rejection handler작성법을 확인하세요.
defaultMaxListeners	기본적으로 단일 이벤트에 대해 최대 청 10 취자 수를 등록할 수 있습니다. 이 제한은 이 메서드를 사용하여 emitter.setMaxListeners(n) 개별 EventEmitter 인스턴스에 대해 변경할 수 있습니다. 모든EventEmitter 인스턴스의 기본값을 변경하려면 속성을 events.defaultMaxListeners 사용할 수 있습니다. 이 값이 양수가 아니면 a RangeError 가 던져집니다. 설정을 할 때 events.defaultMaxListeners 는 주의해야 합니다. 변경은 변경 이전에 생성된 인스턴스를 포함해 모든EventEmitter 인스턴스에 영향을 미치기 때문입니다. 하지만 콜링 emitter.setMaxListeners(n) 은 여전히 우선순위가 있습니다 events.defaultMaxListeners. 이것은 엄격한 한계가 아닙니다. 인스턴스는 EventEmitter 더 많은 리스너를 추가할 수 있게 하지만, stderr에 "가능한 EventEmitter 메모리 누수가 감지되었다"는 트레이스 경고를 출력합니다. 임의의 단일 EventEmitter, 에 대해 emitter.getMaxListeners() 와 emitter.setMaxListeners() 메서드를 사용하여 일시적으로 이 경고를 피할 수 있습니다: import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.setMaxListeners(emitter.getMaxListeners() + 1); emitter.once('event', () => { // do stuff emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0)); }); --trace-warnings 명령줄 플래그는 이러한 경고의 스택 트레이스를 표시하는 데 사용할 수 있습니다. 발신된 경고는 추가 emittertypecount , 를 포함해 검사 process.on('warning') 할 수 있으며, 각각 이벤트 방출기 인스턴스, 이벤트 이름, 연결된 청취자 수를 나타냅니다. 그 name 속성은 로 'MaxListenersExceededWarning'설정되어 있습니다.
errorMonitor	이 심볼은 이벤트만 모니터링 'error' 하는 리스너를 설치하는 데 사용됩니다. 이 심볼을 사용해 설치된 리스너는 일반 'error' 리스너보다 먼저 호출됩니다. 이 심볼을 사용하는 리스너를 설치해도 이벤트가 'error' 발생한 후 동작이 변하지 않습니다. 따라서 일반 'error' 리스너가 설치되지 않으면 프로세스가 여전히 크래시됩니다.

메서드

addListener("close", () => void)	이벤트 내보내기 다음을 비롯한 문서에 대해 정의된 이벤트입니다. 닫기 data 끝 오류 pause 읽을 이력서
addListener("data", (chunk: any) => void)
addListener("end", () => void)
addListener("error", (err: Error) => void)
addListener("pause", () => void)
addListener("readable", () => void)
addListener("resume", () => void)
addListener(string | symbol, (args: any[]) => void)
asIndexedPairs(Pick<ArrayOptions, "signal">)	이 방법은 기본 스트림의 청크와 형식의 [index, chunk]카운터가 결합된 새로운 스트림을 반환합니다. 첫 번째 인덱스 값은 이 0 것이며, 생성된 청크마다 1씩 증가합니다.
destroy(Error)	스트림을 삭제합니다. 선택적으로 이벤트를 방출 'error' 하고, 이벤트를 'close' 방출합니다(가 로 emitClose설정되지 않는 한false). 이 호출 후에는 읽기 가능한 스트림이 내부 자원을 해제하고 이후 호출 push() 은 무시됩니다. 한 번 호출되면 destroy() 추가 호출은 no-op이 되며, 에서 외 _destroy()'error'에는 오류 없이 로 표시됩니다. 구현자는 이 메서드를 덮어쓰지 말고 대신 를 구현 readable._destroy()해야 합니다.
drop(number, Pick<ArrayOptions, "signal">)	이 메서드는 처음부터 첫 번째 제한 청크가 삭제된 새로운 스트림을 반환합니다.
emit("close")
emit("data", any)
emit("end")
emit("error", Error)
emit("pause")
emit("readable")
emit("resume")
emit(string | symbol, any[])
every((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, ArrayOptions)	이 방법은 스트림 내 각 청크에서 Array.prototype.every을 호출하여 기다리는 반환값이 fn에 대해 진실한지 확인하는 것과 유사 합니다. 청크 ed 반환값에 대한 await 호출이 falsy가 되면, 스트림은 파괴되고 약속은 로 이행false됩니다. 모든 fn 호출이 청크에 대해 진리값을 반환하면, 약속은 로 true성취됩니다.
filter((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, ArrayOptions)	이 방법은 스트림을 필터링할 수 있게 해줍니다. 스트림의 각 청크마다 fn 함수가 호출되고, 만약 truey 값을 반환하면 그 청크가 결과 스트림에 전달됩니다. fn 함수가 약속을 반환하면 그 약속은 ed가 됩니다await.
find((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, ArrayOptions)
find<T>((data: any, options?: Pick<ArrayOptions, "signal">) => data, ArrayOptions)	이 방법은 스트림 내 각 청크에서 Array.prototype.find을 호출하여 fn에 대해 진리값이 있는 청크를 찾는 것과 유사 합니다. fn 호출의 기다리는 반환값이 진실이 되면, 스트림은 파괴되고 약속은 fn이 진실 값을 반환한 값으로 이행됩니다. 모든 fn 호출이 청크에 대해 가짜 값을 반환하면, 약속은 로 성취 undefined됩니다.
flatMap((data: any, options?: Pick<ArrayOptions, "signal">) => any, ArrayOptions)	이 방법은 각 청크에 주어진 콜백을 적용한 후 결과를 평탄화하여 새로운 스트림을 반환합니다. fn에서 스트림이나 다른 반복 가능하거나 비동기 반복 가능한 스트림을 반환할 수 있으며, 결과 스트림은 반환된 스트림에 병합(평탄화)됩니다.
forEach((data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>, ArrayOptions)	이 방법은 스트림을 반복할 수 있게 해줍니다. 스트림의 각 청크마다 fn 함수가 호출됩니다. fn 함수가 약속을 반환하면 그 약속은 ed가 됩니다await. 이 방법은 선택적으로 청크를 동시에 처리할 수 있다는 점에서 루프와 for await...of 다릅니다. 또한, 반복은 forEach 옵션을 통과 signal 하고 관련된 AbortController를 중단해야 하며, for await...of 는 또는 break로 중단 return 할 수 있습니다. 어느 쪽이든 개울은 파괴될 것입니다. 이 방법은 이벤트 수신 'data' 과 달리 기본 메커니즘 내 이벤트를 사용 readable 하며 동시 fn 호출 수를 제한할 수 있습니다.
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)	반복자에서 읽을 수 있는 스트림을 생성하는 유틸리티 방법.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)	웹Readable에서 생성 ReadableStream 하는 유틸리티 메서드 .
isDisturbed(Readable | ReadableStream)	스트림이 읽혔는지 취소되었는지 반환합니다.
isPaused()	이 메서드는 readable.isPaused() .의 Readable현재 작동 상태를 반환합니다. 이는 주로 방법의 readable.pipe() 기초가 되는 메커니즘에서 사용됩니다. 대부분의 경우, 이 방법을 직접 사용할 이유가 없습니다. const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false
iterator({ destroyOnReturn?: boolean })	이 방법으로 생성된 반복자는 루프가 for await...ofreturn, break, 또는 throw반복 중 오류가 발생하면 스트림 파괴를 취소하거나, 반복 중 스트림이 오류를 발생시킨다면 스트림을 파괴할 수 있는 옵션을 제공합니다.
map((data: any, options?: Pick<ArrayOptions, "signal">) => any, ArrayOptions)	이 방법은 스트림 전체에 매핑할 수 있게 해줍니다. 스트림의 모든 청크마다 fn 함수가 호출됩니다. fn 함수가 약속을 반환하면, 그 약속은 결과 스트림에 전달되기 전에 ed 처리됩니다await.
on("close", () => void)
on("data", (chunk: any) => void)
on("end", () => void)
on("error", (err: Error) => void)
on("pause", () => void)
on("readable", () => void)
on("resume", () => void)
on(string | symbol, (args: any[]) => void)
once("close", () => void)
once("data", (chunk: any) => void)
once("end", () => void)
once("error", (err: Error) => void)
once("pause", () => void)
once("readable", () => void)
once("resume", () => void)
once(string | symbol, (args: any[]) => void)
pause()	이 readable.pause() 방법은 흐름 모드에 있는 스트림이 이벤트를 방출하지 않 'data' 게 하여 흐름 모드에서 벗어나게 만듭니다. 이용 가능한 모든 데이터는 내부 버퍼에 남아 있습니다. 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() 이벤트 리스너가 'readable' 있으면 이 메서드는 효과가 없습니다.
prependListener("close", () => void)
prependListener("data", (chunk: any) => void)
prependListener("end", () => void)
prependListener("error", (err: Error) => void)
prependListener("pause", () => void)
prependListener("readable", () => void)
prependListener("resume", () => void)
prependListener(string | symbol, (args: any[]) => void)
prependOnceListener("close", () => void)
prependOnceListener("data", (chunk: any) => void)
prependOnceListener("end", () => void)
prependOnceListener("error", (err: Error) => void)
prependOnceListener("pause", () => void)
prependOnceListener("readable", () => void)
prependOnceListener("resume", () => void)
prependOnceListener(string | symbol, (args: any[]) => void)
push(any, BufferEncoding)
read(number)	이 메서드는 readable.read() 내부 버퍼에서 데이터를 읽어내어 반환합니다. 읽을 수 있는 데이터가 없으면 반환 null 됩니다. 기본적으로 인코딩 Buffer 이 지정되어 있거나 스트림이 객체 모드로 동작하지 않는 한 데이터는 객체로 readable.setEncoding() 반환됩니다. 선택적 size 인자는 읽을 특정 바이트 수를 지정합니다. 읽을 수 없는 바이트는 스트림이 종료size 반환되며, 이 경우 내부 버퍼에 남아 있는 모든 데이터가 반환됩니다. null 인자가 지정되지 않으면 size 내부 버퍼에 포함된 모든 데이터가 반환됩니다. size 인수는 1 GiB 이하여야 합니다. 이 메서드는 readable.read() 일시정지 모드로 동작하는 스트림에서만 Readable 호출되어야 합니다. 플로잉 모드 readable.read() 에서는 내부 버퍼가 완전히 배수될 때까지 자동으로 호출됩니다. 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.'); }); 각 호출 readable.read() 은 데이터 덩어리, 즉 null를 반환합니다. 청크들은 연결되어 있지 않습니다. 현재 버퍼에 있는 모든 데이터를 소비하려면 루프가 while 필요합니다. 큰 파일을 .read() 읽으면 지금까지 버퍼된 모든 내용을 소모한 후 로 반환 null될 수 있지만, 아직 버퍼링되지 않은 데이터가 더 남아 있습니다. 이 경우 버퍼에 더 많은 데이터가 있을 때 새로운 'readable' 이벤트가 발생한다. 마지막으로 'end' 더 이상 데이터가 없을 때 이벤트가 방출됩니다. 따라서 파일의 전체 내용을 readable읽으려면 여러 'readable' 이벤트에 걸쳐 청크를 수집해야 합니다: const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); }); 객체 모드의 스트림은 Readable 인수의 값 readable.read(size) 과 상관없이 에 대한 size호출에서 항상 단일 항목을 반환합니다. 메서드가 readable.read() 데이터 'data' 덩어리를 반환하면 이벤트도 함께 발생하게 됩니다. 이벤트가 발신한 후 'end'을 호출하면 다시 돌아null옵니다. 런타임 오류는 발생하지 않습니다.
reduce<T>((previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T, undefined, Pick<ArrayOptions, "signal">)	이 메서드는 스트림의 각 청크에 대해 fn 을 순서대로 호출하여 이전 요소에 대한 계산 결과를 전달합니다. 이 방법은 축소의 최종 값에 대한 약속을 반환합니다. 초기 값이 제공되지 않으면 스트림의 첫 번째 청크가 초기 값으로 사용됩니다. 스트림이 비어 있으면, 코드의 속성을 가진 TypeError a로 ERR_INVALID_ARGS 약속을 거부합니다. 리듀서 함수는 스트림을 요소별로 반복하여 동 시 성 매개변수나 병렬성이 없습니다. 동시 감소를 수행하려면 메서드에 readable.map 비동기 함수를 추출할 수 있습니다.
reduce<T>((previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T, T, Pick<ArrayOptions, "signal">)
removeListener("close", () => void)
removeListener("data", (chunk: any) => void)
removeListener("end", () => void)
removeListener("error", (err: Error) => void)
removeListener("pause", () => void)
removeListener("readable", () => void)
removeListener("resume", () => void)
removeListener(string | symbol, (args: any[]) => void)
resume()	이 readable.resume() 방법은 명시적으로 일시정지된 Readable 스트림이 이벤트를 다시 방출 'data' 하게 하여 스트림을 흐름 모드로 전환하게 합니다. 이 readable.resume() 방법은 실제로 데이터를 처리하지 않고도 스트림의 데이터를 완전히 소비할 수 있습니다: getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); }); readable.resume() 이벤트 리스너가 'readable' 있으면 이 메서드는 효과가 없습니다.
setEncoding(BufferEncoding)	이 메서드는 readable.setEncoding() 스트림에서 Readable 읽는 데이터의 문자 인코딩을 설정합니다. 기본적으로 인코딩은 할당되지 않으며 스트림 데이터는 객체로 Buffer 반환됩니다. 인코딩을 설정하면 스트림 데이터가 객체가 아닌 Buffer 지정된 인코딩의 문자열로 반환됩니다. 예를 들어, 호출 readable.setEncoding('utf8') 하면 출력 데이터가 UTF-8 데이터로 해석되어 문자열로 전달됩니다. 호출하면 readable.setEncoding('hex') 데이터가 16진수 문자열 형식으로 인코딩됩니다. 스트림은 Readable 단순히 객체로 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?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, ArrayOptions)	이 방법은 스트림 내 각 청크에서 Array.prototype.some을 호출하여 기다리는 반환값(또는 진리 값)이 될 때까지 호출하는 것과 유사 true 합니다. 청크 ed 반환값에 대한 await 호출이 진리가 되면, 스트림은 파괴되고 약속은 로 이루어집니다.true 만약 청크에 대한 fn 호출이 진리값(truthy value)을 반환하지 않으면, 약속은 로 충족 false됩니다.
take(number, Pick<ArrayOptions, "signal">)	이 방법은 첫 번째 제한 청크를 가진 새로운 스트림을 반환합니다.
toArray(Pick<ArrayOptions, "signal">)	이 방법은 스트림의 내용을 쉽게 얻을 수 있게 해줍니다. 이 방법은 전체 스트림을 메모리에 읽기 때문에 스트림의 이점을 상쇄합니다. 상호운용성과 편의성을 위해 설계된 것이지, 스트림을 소비하는 주된 방법이 아닙니다.
toWeb(Readable, { strategy?: QueuingStrategy<any> })	. 에서 웹 ReadableStreamReadable을 생성하는 유틸리티 방법
unpipe(WritableStream)	readable.unpipe() 이 방법은 Writable 방식으로 이전에 부착된 물줄기를 분리하는 방식입니다. 만약 이 destination 명시되지 않으면 모든 파이프가 분리됩니다. 만약 가 destination 지정되었지만 파이프가 설정되어 있지 않으면, 메서드는 아무런 동작을 하지 않습니다. 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)	로 chunk 패스하면 null 스트림의 끝(EOF)을 알리고, 와 동일readable.push(null)하게 동작하며, 그 이후에는 더 이상 데이터를 쓸 수 없습니다. EOF 신호는 버퍼 끝에 배치되며, 버퍼된 데이터는 여전히 플러싱됩니다. 이 readable.unshift() 방법은 데이터 덩어리를 내부 버퍼로 다시 밀어냅니다. 이는 스트림이 소스에서 낙관적으로 가져온 데이터를 "소모 해제"해야 하는 특정 상황에서 유용합니다. stream.unshift(chunk) 이벤트가 'end' 발생한 후에는 메서드를 호출할 수 없으며, 그렇지 않으면 런타임 오류가 발생합니다. 자주 사용하는 stream.unshift() 개발자들은 스트림 사용 Transform 으로 전환하는 것을 고려해야 합니다. 자세한 내용은 섹션을 API for stream implementers 참조하세요. // 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; } } } 푸시와 달리, 스트림 stream.unshift(chunk) 의 내부 읽기 상태를 초기화하여 읽기 과정을 종료하지 않습니다. 이는 읽기 중(즉, readable.unshift() 구현 내 사용자 지정 스트림에서) 호출될 경우 예상치 못한 결과를 초래할 수 있습니다. 호출 readable.unshift() 후 즉시 푸시 를 하면 읽기 상태가 적절히 초기화되지만, 읽기 수행 중에는 호출을 피 readable.unshift() 하는 것이 가장 좋습니다.
wrap(ReadableStream)	Node.js 0.10 이전에는 스트림즈가 현재 정의된 전체 node:stream 모듈 API를 구현하지 않았습니다. (자세한 내용은 참고하세요 Compatibility .) 이벤트를 'data' 방출하고 일 시정지 메서드가 자문 전용 메서드인 오래된 Node.js 라이브러리를 사용할 때, 이 readable.wrap() 메서드를 사용해 기존 스트림을 데이터 소스로 사용하는 스트림을 Readable 생성할 수 있습니다. 이 방법은 거의 사용할 필요가 readable.wrap() 없지만, 오래된 Node.js 애플리케이션 및 라이브러리와의 상호작용을 편리하게 하기 위해 제공되었습니다. 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]()	와 통화 readable.destroy()AbortError 하고 스트림이 끝나면 이행되는 약속을 반환합니다.
[asyncIterator]()

상속된 메서드

addAbortListener(AbortSignal, (event: Event) => void)	제공signal된 행사에서 한 번 abort 들어보세요. 중단 신호로 이벤트를 abort 듣는 것은 안전하지 않으며, 신호를 가진 다른 제3자가 호출 e.stopImmediatePropagation()할 수 있어 자원 누출로 이어질 수 있습니다. 안타깝게도 웹 표준을 위반하기 때문에 Node.js 변경할 수 없습니다. 또한, 원래 API는 리스너를 제거하는 것을 쉽게 잊게 만듭니다. 이 API는 이벤트 stopImmediatePropagation 를 듣고 리스너가 실행되는 것을 막지 않게 함으로써 이 두 가지 문제를 해결함으로써 Node.js API에서 s를 안전하게 사용할 AbortSignal수 있게 해줍니다. 일회용 기기를 반품하여 더 쉽게 구독 취소할 수 있습니다. import { addAbortListener } from 'node:events'; function example(signal) { let disposable; try { signal.addEventListener('abort', (e) => e.stopImmediatePropagation()); disposable = addAbortListener(signal, (e) => { // Do something when signal is aborted. }); } finally { disposable?.[Symbol.dispose](); } }
compose<T>(T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, { signal: AbortSignal })
eventNames()	이미터가 수신기를 등록한 이벤트를 나열하는 배열을 반환합니다. 배열의 값은 문자열 또는 Symbol. import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)	eventName이벤트에 대한 수신기 배열의 복사본을 반환합니다. s에 대해서는 EventEmitter이미터를 호출 .listeners 하는 것과 정확히 동일하게 동작합니다. s에 대해 EventTarget이벤트 타겟에 대해 이벤트 청취자를 얻는 유일한 방법입니다. 이는 디버깅 및 진단 목적으로 유용합니다. import { getEventListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); const listener = () => console.log('Events are fun'); ee.on('foo', listener); console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ] } { const et = new EventTarget(); const listener = () => console.log('Events are fun'); et.addEventListener('foo', listener); console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ] }
getMaxListeners()	EventEmitter 설정되거나 emitter.setMaxListeners(n)기본값인 <xref:EventEmitter.defaultMaxListeners> 대한 현재 최대 수신기 값을 반환합니다.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)	현재 설정된 최대 청취자 수를 반환합니다. s에 대해서는 EventEmitter이미터를 호출 .getMaxListeners 하는 것과 정확히 동일하게 동작합니다. s에 대해서는 EventTarget이벤트 대상의 최대 이벤트 청취자를 얻는 유일한 방법입니다. 단일 EventTarget의 이벤트 핸들러 수가 최대 집합을 초과하면 EventTarget은 경고를 출력합니다. import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events'; { const ee = new EventEmitter(); console.log(getMaxListeners(ee)); // 10 setMaxListeners(11, ee); console.log(getMaxListeners(ee)); // 11 } { const et = new EventTarget(); console.log(getMaxListeners(et)); // 10 setMaxListeners(11, et); console.log(getMaxListeners(et)); // 11 }
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)	주어진 eventName 에 등록 emitter된 리스터 수를 반환하는 클래스 메서드입니다. import { EventEmitter, listenerCount } from 'node:events'; const myEmitter = new EventEmitter(); myEmitter.on('event', () => {}); myEmitter.on('event', () => {}); console.log(listenerCount(myEmitter, 'event')); // Prints: 2
listenerCount<K>(string | symbol, Function)	eventName이벤트를 수신 대기하는 수신기 수를 반환합니다. listener 제공된 경우 수신기가 이벤트 수신기 목록에서 발견된 횟수를 반환합니다.
listeners<K>(string | symbol)	eventName이벤트에 대한 수신기 배열의 복사본을 반환합니다. server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]
off<K>(string | symbol, (args: any[]) => void)	emitter.removeListener()의 별칭입니다.
on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions)	import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here 사건을 반복하는 eventName 반환과 AsyncIterator 반환. 만약 이 방출'error'된다 EventEmitter 면 던질 것입니다. 루프를 종료할 때 모든 청취자를 제거합니다. 각 반복에서 반환되는 값 value 은 방출된 이벤트 인자로 구성된 배열입니다. A AbortSignal 는 이벤트 대기 취소에 사용할 수 있습니다: import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ac = new AbortController(); (async () => { const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo', { signal: ac.signal })) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here })(); process.nextTick(() => ac.abort()); 반복을 종료할 이벤트 이름 배열을 지정하는 옵션을 사용 close 하세요: import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); ee.emit('close'); }); for await (const event of on(ee, 'foo', { close: ['close'] })) { console.log(event); // prints ['bar'] [42] } // the loop will exit after 'close' is emitted console.log('done'); // prints 'done'
on(EventTarget, string, StaticEventEmitterIteratorOptions)
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)	이 a는 주어진 사건을 방출할 때 EventEmitter 성립되거나, 대기 중에 방출 'error' 하면 거부 EventEmitter 되는 a를 만듭니다Promise. Promise will은 주어진 이벤트에 대해 방출된 모든 인수의 배열로 해결됩니다. 이 방법은 의도적으로 일반적이며, 특별한'error' 이벤트 의미론이 없고 이벤트를 'error' 감지하지 않는 웹 플랫폼 EventTarget 인터페이스와 함께 작동합니다. import { once, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); process.nextTick(() => { ee.emit('myevent', 42); }); const [value] = await once(ee, 'myevent'); console.log(value); const err = new Error('kaboom'); process.nextTick(() => { ee.emit('error', err); }); try { await once(ee, 'myevent'); } catch (err) { console.error('error happened', err); } 이벤트 특별 처리 'error' 는 다음 이벤트를 기다리는 경우에만 events.once() 사용됩니다. 만약 events.once() 가 '이벤트 자체를error' 기다리는 데 사용된다면, 특별한 처리 없이 다른 종류의 이벤트와 동일하게 취급됩니다: import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); once(ee, 'error') .then(([err]) => console.log('ok', err.message)) .catch((err) => console.error('error', err.message)); ee.emit('error', new Error('boom')); // Prints: ok boom 이벤트 AbortSignal 를 기다리는 것을 취소하는 데 사용할 수 있습니다: import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); const ac = new AbortController(); async function foo(emitter, event, signal) { try { await once(emitter, event, { signal }); console.log('event emitted!'); } catch (error) { if (error.name === 'AbortError') { console.error('Waiting for the event was canceled!'); } else { console.error('There was an error', error.message); } } } foo(ee, 'foo', ac.signal); ac.abort(); // Abort waiting for the event ee.emit('foo'); // Prints: Waiting for the event was canceled!
once(EventTarget, string, StaticEventEmitterOptions)
pipe<T>(T, { end?: boolean })
rawListeners<K>(string | symbol)	래퍼(예: eventName만든 래퍼)를 포함하여 .once()이벤트에 대한 수신기 배열의 복사본을 반환합니다. import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.once('log', () => console.log('log once')); // Returns a new Array with a function `onceWrapper` which has a property // `listener` which contains the original listener bound above const listeners = emitter.rawListeners('log'); const logFnWrapper = listeners[0]; // Logs "log once" to the console and does not unbind the `once` event logFnWrapper.listener(); // Logs "log once" to the console and removes the listener logFnWrapper(); emitter.on('log', () => console.log('log persistently')); // Will return a new Array with a single function bound by `.on()` above const newListeners = emitter.rawListeners('log'); // Logs "log persistently" twice newListeners[0](); emitter.emit('log');
removeAllListeners(string | symbol)	모든 수신기 또는 지정된 eventName제거합니다. 특히 다른 구성 요소 또는 모듈(예: 소켓 또는 파일 스트림)에서 EventEmitter 인스턴스를 만든 경우 코드의 다른 위치에 추가된 수신기를 제거하는 것은 잘못된 방법입니다. 호출을 연결할 수 있도록 EventEmitter대한 참조를 반환합니다.
setMaxListeners(number)	기본적으로 EventEmitter특정 이벤트에 대해 10 개 이상의 수신기가 추가되면 경고를 출력합니다. 이는 메모리 누수 찾기에 도움이 되는 유용한 기본값입니다. emitter.setMaxListeners() 메서드를 사용하면 이 특정 EventEmitter 인스턴스에 대한 제한을 수정할 수 있습니다. 값을 Infinity(또는 0)로 설정하여 무제한 수신기를 나타낼 수 있습니다. 호출을 연결할 수 있도록 EventEmitter대한 참조를 반환합니다.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[])	import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

생성자 세부 정보

Readable(ReadableOptions<Readable>)

new Readable(opts?: ReadableOptions<Readable>)

매개 변수

opts

ReadableOptions<Readable>

속성 세부 정보

closed

true 방출된 이후 'close' 의 신호입니다.

closed: boolean

속성 값

boolean

destroyed

true 그 이후 readable.destroy() 에야 호출되었습니다.

destroyed: boolean

속성 값

boolean

errored

스트림이 오류가 발생하면 오류를 반환합니다.

errored: null | Error

속성 값

null | Error

readable

는 trueread를 호출해도 안전한지, 즉 스트림이 파괴되거나 방출 'error' 되지 않았다는 의미입니다.'end'

readable: boolean

속성 값

boolean

readableAborted

스트림이 방출되기 전에 'end'파괴되었거나 오류가 발생했는지 반환합니다.

readableAborted: boolean

속성 값

boolean

readableDidRead

방출되었는지 여부 'data' 에 대해 반환합니다.

readableDidRead: boolean

속성 값

boolean

readableEncoding

주어진 encoding 스트림의 속성 Readable 에 대한 게터입니다. 이 속성은 encodingsetEncoding 메서드를 사용하여 설정할 수 있습니다.

readableEncoding: null | BufferEncoding

속성 값

null | BufferEncoding

readableEnded

이벤트가 방출될 때 true 가 됩니다'end'.

readableEnded: boolean

속성 값

boolean

readableFlowing

이 특성은 Readable 섹션에서 설명된 하천의 현재 상태를 반영합니다.

readableFlowing: null | boolean

속성 값

null | boolean

readableHighWaterMark

이 를 highWaterMark생성할 때 전달된 값을 Readable 반환합니다.

readableHighWaterMark: number

속성 값

number

readableLength

이 속성은 읽을 준비가 된 큐 내 바이트(또는 객체)의 수를 포함합니다. 이 값 highWaterMark은 .

readableLength: number

속성 값

number

readableObjectMode

주어진 objectMode 스트림의 속성 Readable 에 대한 게터입니다.

readableObjectMode: boolean

속성 값

boolean

상속된 속성 세부 정보

captureRejections

값: 불리언

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

static captureRejections: boolean

속성 값

boolean

상속됨 Stream.capture거절

captureRejectionSymbol

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

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

static captureRejectionSymbol: typeof captureRejectionSymbol

속성 값

typeof captureRejectionSymbol

상속됨 Stream.capture거부 심볼

defaultMaxListeners

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

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

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

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

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

발신된 경고는 추가 emittertypecount , 를 포함해 검사 process.on('warning') 할 수 있으며, 각각 이벤트 방출기 인스턴스, 이벤트 이름, 연결된 청취자 수를 나타냅니다. 그 name 속성은 로 'MaxListenersExceededWarning'설정되어 있습니다.

static defaultMaxListeners: number

속성 값

number

상속받은 Stream.defaultMaxListeners

errorMonitor

이 심볼은 이벤트만 모니터링 'error' 하는 리스너를 설치하는 데 사용됩니다. 이 심볼을 사용해 설치된 리스너는 일반 'error' 리스너보다 먼저 호출됩니다.

이 심볼을 사용하는 리스너를 설치해도 이벤트가 'error' 발생한 후 동작이 변하지 않습니다. 따라서 일반 'error' 리스너가 설치되지 않으면 프로세스가 여전히 크래시됩니다.

static errorMonitor: typeof errorMonitor

속성 값

typeof errorMonitor

상속받은 출처 Stream.errorMonitor

메서드 세부 정보

addListener("close", () => void)

이벤트 내보내기 다음을 비롯한 문서에 대해 정의된 이벤트입니다.

1. 닫기
2. data
3. 끝
4. 오류
5. pause
6. 읽을
7. 이력서

function addListener(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

addListener("data", (chunk: any) => void)

function addListener(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

addListener("end", () => void)

function addListener(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

addListener("error", (err: Error) => void)

function addListener(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

addListener("pause", () => void)

function addListener(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

addListener("readable", () => void)

function addListener(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

addListener("resume", () => void)

function addListener(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

asIndexedPairs(Pick<ArrayOptions, "signal">)

이 방법은 기본 스트림의 청크와 형식의 [index, chunk]카운터가 결합된 새로운 스트림을 반환합니다. 첫 번째 인덱스 값은 이 0 것이며, 생성된 청크마다 1씩 증가합니다.

function asIndexedPairs(options?: Pick<ArrayOptions, "signal">): Readable

매개 변수

options

Pick<ArrayOptions, "signal">

반품

Readable

인덱스 쌍들의 스트림입니다.

destroy(Error)

스트림을 삭제합니다. 선택적으로 이벤트를 방출 'error' 하고, 이벤트를 'close' 방출합니다(가 로 emitClose설정되지 않는 한false). 이 호출 후에는 읽기 가능한 스트림이 내부 자원을 해제하고 이후 호출 push() 은 무시됩니다.

한 번 호출되면 destroy() 추가 호출은 no-op이 되며, 에서 외 _destroy()'error'에는 오류 없이 로 표시됩니다.

구현자는 이 메서드를 덮어쓰지 말고 대신 를 구현 readable._destroy()해야 합니다.

function destroy(error?: Error): Readable

매개 변수

error

Error

이 오류는 이벤트 시 'error' 페이로드로 전달됩니다

반품

Readable

drop(number, Pick<ArrayOptions, "signal">)

이 메서드는 처음부터 첫 번째 제한 청크가 삭제된 새로운 스트림을 반환합니다.

function drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable

매개 변수

limit

number

읽을 수 있는 값에서 삭제할 수 있는 청크 수.

options

Pick<ArrayOptions, "signal">

반품

Readable

처음부터 제한 청크가 떨어지는 스트림.

emit("close")

function emit(event: "close"): boolean

매개 변수

event

"close"

반품

boolean

emit("data", any)

function emit(event: "data", chunk: any): boolean

매개 변수

event

"data"

chunk

any

반품

boolean

emit("end")

function emit(event: "end"): boolean

매개 변수

event

"end"

반품

boolean

emit("error", Error)

function emit(event: "error", err: Error): boolean

매개 변수

event

"error"

err

Error

반품

boolean

emit("pause")

function emit(event: "pause"): boolean

매개 변수

event

"pause"

반품

boolean

emit("readable")

function emit(event: "readable"): boolean

매개 변수

event

"readable"

반품

boolean

emit("resume")

function emit(event: "resume"): boolean

매개 변수

event

"resume"

반품

boolean

emit(string | symbol, any[])

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

매개 변수

event

string | symbol

args

any[]

반품

boolean

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

이 방법은 스트림 내 각 청크에서 Array.prototype.every을 호출하여 기다리는 반환값이 fn에 대해 진실한지 확인하는 것과 유사 합니다. 청크 ed 반환값에 대한 await 호출이 falsy가 되면, 스트림은 파괴되고 약속은 로 이행false됩니다. 모든 fn 호출이 청크에 대해 진리값을 반환하면, 약속은 로 true성취됩니다.

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

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>

스트림의 각 청크를 호출하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Promise<boolean>

fn이 true 모든 청크에 대해 진 리 값을 반환하는지 평가하는 약속입니다.

filter((data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, ArrayOptions)

이 방법은 스트림을 필터링할 수 있게 해줍니다. 스트림의 각 청크마다 fn 함수가 호출되고, 만약 truey 값을 반환하면 그 청크가 결과 스트림에 전달됩니다. fn 함수가 약속을 반환하면 그 약속은 ed가 됩니다await.

function filter(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Readable

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>

스트림에서 청크를 필터링하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Readable

술어 fn으로 필터링된 스트림입니다.

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

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

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>

options

ArrayOptions

반품

Promise<any>

find<T>((data: any, options?: Pick<ArrayOptions, "signal">) => data, ArrayOptions)

이 방법은 스트림 내 각 청크에서 Array.prototype.find을 호출하여 fn에 대해 진리값이 있는 청크를 찾는 것과 유사 합니다. fn 호출의 기다리는 반환값이 진실이 되면, 스트림은 파괴되고 약속은 fn이 진실 값을 반환한 값으로 이행됩니다. 모든 fn 호출이 청크에 대해 가짜 값을 반환하면, 약속은 로 성취 undefined됩니다.

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

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => data

스트림의 각 청크를 호출하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Promise<undefined | T>

fn이 진리값 undefined 으로 평가한 첫 번째 청크에 대한 약속 또는 원소가 발견되지 않았을 때를 평가합니다.

flatMap((data: any, options?: Pick<ArrayOptions, "signal">) => any, ArrayOptions)

이 방법은 각 청크에 주어진 콜백을 적용한 후 결과를 평탄화하여 새로운 스트림을 반환합니다.

fn에서 스트림이나 다른 반복 가능하거나 비동기 반복 가능한 스트림을 반환할 수 있으며, 결과 스트림은 반환된 스트림에 병합(평탄화)됩니다.

function flatMap(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => any

스트림의 모든 청크를 매핑하는 함수입니다. 비동기 문제일 수도 있습니다. 개울이나 발전기일 수도 있습니다.

options

ArrayOptions

반품

Readable

함수 fn으로 평평하게 매핑된 스트림입니다.

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

이 방법은 스트림을 반복할 수 있게 해줍니다. 스트림의 각 청크마다 fn 함수가 호출됩니다. fn 함수가 약속을 반환하면 그 약속은 ed가 됩니다await.

이 방법은 선택적으로 청크를 동시에 처리할 수 있다는 점에서 루프와 for await...of 다릅니다. 또한, 반복은 forEach 옵션을 통과 signal 하고 관련된 AbortController를 중단해야 하며, for await...of 는 또는 break로 중단 return 할 수 있습니다. 어느 쪽이든 개울은 파괴될 것입니다.

이 방법은 이벤트 수신 'data' 과 달리 기본 메커니즘 내 이벤트를 사용 readable 하며 동시 fn 호출 수를 제한할 수 있습니다.

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

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>

스트림의 각 청크를 호출하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Promise<void>

스트림이 끝나면 하는 약속이었다.

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

반복자에서 읽을 수 있는 스트림을 생성하는 유틸리티 방법.

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

매개 변수

iterable

Iterable<any> | AsyncIterable<any>

객체가 반복 가능한 프로토콜을 Symbol.asyncIteratorSymbol.iterator 구현하는 경우입니다. null 값이 전달되면 '오류' 이벤트를 생성합니다.

options

ReadableOptions<Readable>

옵션들은 제공됩니다.new stream.Readable([options]) 기본적으로 Readable.from() 는 로 설정되며, 이 부분은 명시적으로 로 설정하여 options.objectMode 옵트아웃하지 않는 한 로 설정 trueoptions.objectMode됩니다.false

반품

Readable

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

웹Readable에서 생성 ReadableStream 하는 유틸리티 메서드 .

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

매개 변수

readableStream

ReadableStream<any>

options

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

반품

Readable

isDisturbed(Readable | ReadableStream)

스트림이 읽혔는지 취소되었는지 반환합니다.

static function isDisturbed(stream: Readable | ReadableStream): boolean

매개 변수

stream

Readable | ReadableStream

반품

boolean

isPaused()

이 메서드는 readable.isPaused() .의 Readable현재 작동 상태를 반환합니다. 이는 주로 방법의 readable.pipe() 기초가 되는 메커니즘에서 사용됩니다. 대부분의 경우, 이 방법을 직접 사용할 이유가 없습니다.

const readable = new stream.Readable();

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

function isPaused(): boolean

반품

boolean

iterator({ destroyOnReturn?: boolean })

이 방법으로 생성된 반복자는 루프가 for await...ofreturn, break, 또는 throw반복 중 오류가 발생하면 스트림 파괴를 취소하거나, 반복 중 스트림이 오류를 발생시킨다면 스트림을 파괴할 수 있는 옵션을 제공합니다.

function iterator(options?: { destroyOnReturn?: boolean }): AsyncIterator<any, any, any>

매개 변수

options

{ destroyOnReturn?: boolean }

반품

AsyncIterator<any, any, any>

map((data: any, options?: Pick<ArrayOptions, "signal">) => any, ArrayOptions)

이 방법은 스트림 전체에 매핑할 수 있게 해줍니다. 스트림의 모든 청크마다 fn 함수가 호출됩니다. fn 함수가 약속을 반환하면, 그 약속은 결과 스트림에 전달되기 전에 ed 처리됩니다await.

function map(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => any

스트림의 모든 청크를 매핑하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Readable

함수 fn으로 매핑된 스트림입니다.

on("close", () => void)

function on(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

on("data", (chunk: any) => void)

function on(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

on("end", () => void)

function on(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

on("error", (err: Error) => void)

function on(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

on("pause", () => void)

function on(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

on("readable", () => void)

function on(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

on("resume", () => void)

function on(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

once("close", () => void)

function once(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

once("data", (chunk: any) => void)

function once(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

once("end", () => void)

function once(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

once("error", (err: Error) => void)

function once(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

once("pause", () => void)

function once(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

once("readable", () => void)

function once(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

once("resume", () => void)

function once(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

pause()

이 readable.pause() 방법은 흐름 모드에 있는 스트림이 이벤트를 방출하지 않 'data' 게 하여 흐름 모드에서 벗어나게 만듭니다. 이용 가능한 모든 데이터는 내부 버퍼에 남아 있습니다.

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() 이벤트 리스너가 'readable' 있으면 이 메서드는 효과가 없습니다.

function pause(): Readable

반품

Readable

prependListener("close", () => void)

function prependListener(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

prependListener("data", (chunk: any) => void)

function prependListener(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

prependListener("end", () => void)

function prependListener(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

prependListener("error", (err: Error) => void)

function prependListener(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

prependListener("pause", () => void)

function prependListener(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

prependListener("readable", () => void)

function prependListener(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

prependListener("resume", () => void)

function prependListener(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

prependOnceListener("close", () => void)

function prependOnceListener(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

prependOnceListener("data", (chunk: any) => void)

function prependOnceListener(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

prependOnceListener("end", () => void)

function prependOnceListener(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

prependOnceListener("error", (err: Error) => void)

function prependOnceListener(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

prependOnceListener("pause", () => void)

function prependOnceListener(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

prependOnceListener("readable", () => void)

function prependOnceListener(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

prependOnceListener("resume", () => void)

function prependOnceListener(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

push(any, BufferEncoding)

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

매개 변수

chunk

any

encoding

BufferEncoding

반품

boolean

read(number)

이 메서드는 readable.read() 내부 버퍼에서 데이터를 읽어내어 반환합니다. 읽을 수 있는 데이터가 없으면 반환 null 됩니다. 기본적으로 인코딩 Buffer 이 지정되어 있거나 스트림이 객체 모드로 동작하지 않는 한 데이터는 객체로 readable.setEncoding() 반환됩니다.

선택적 size 인자는 읽을 특정 바이트 수를 지정합니다. 읽을 수 없는 바이트는 스트림이 종료size 반환되며, 이 경우 내부 버퍼에 남아 있는 모든 데이터가 반환됩니다. null

인자가 지정되지 않으면 size 내부 버퍼에 포함된 모든 데이터가 반환됩니다.

size 인수는 1 GiB 이하여야 합니다.

이 메서드는 readable.read() 일시정지 모드로 동작하는 스트림에서만 Readable 호출되어야 합니다. 플로잉 모드 readable.read() 에서는 내부 버퍼가 완전히 배수될 때까지 자동으로 호출됩니다.

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

각 호출 readable.read() 은 데이터 덩어리, 즉 null를 반환합니다. 청크들은 연결되어 있지 않습니다. 현재 버퍼에 있는 모든 데이터를 소비하려면 루프가 while 필요합니다. 큰 파일을 .read() 읽으면 지금까지 버퍼된 모든 내용을 소모한 후 로 반환 null될 수 있지만, 아직 버퍼링되지 않은 데이터가 더 남아 있습니다. 이 경우 버퍼에 더 많은 데이터가 있을 때 새로운 'readable' 이벤트가 발생한다. 마지막으로 'end' 더 이상 데이터가 없을 때 이벤트가 방출됩니다.

따라서 파일의 전체 내용을 readable읽으려면 여러 'readable' 이벤트에 걸쳐 청크를 수집해야 합니다:

const chunks = [];

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

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

객체 모드의 스트림은 Readable 인수의 값 readable.read(size) 과 상관없이 에 대한 size호출에서 항상 단일 항목을 반환합니다.

메서드가 readable.read() 데이터 'data' 덩어리를 반환하면 이벤트도 함께 발생하게 됩니다.

이벤트가 발신한 후 'end'을 호출하면 다시 돌아null옵니다. 런타임 오류는 발생하지 않습니다.

function read(size?: number): any

매개 변수

size

number

읽어야 할 데이터 양을 지정하는 선택적 인수.

반품

any

reduce<T>((previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T, undefined, Pick<ArrayOptions, "signal">)

이 메서드는 스트림의 각 청크에 대해 fn 을 순서대로 호출하여 이전 요소에 대한 계산 결과를 전달합니다. 이 방법은 축소의 최종 값에 대한 약속을 반환합니다.

초기 값이 제공되지 않으면 스트림의 첫 번째 청크가 초기 값으로 사용됩니다. 스트림이 비어 있으면, 코드의 속성을 가진 TypeError a로 ERR_INVALID_ARGS 약속을 거부합니다.

리듀서 함수는 스트림을 요소별로 반복하여 동 시 성 매개변수나 병렬성이 없습니다. 동시 감소를 수행하려면 메서드에 readable.map 비동기 함수를 추출할 수 있습니다.

function reduce<T>(fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial?: undefined, options?: Pick<ArrayOptions, "signal">): Promise<T>

매개 변수

fn

(previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T

스트림의 모든 청크를 호출하는 리듀서 함수입니다. 비동기 동기 여부 여부.

initial

undefined

환원에 사용할 초기 값입니다.

options

Pick<ArrayOptions, "signal">

반품

Promise<T>

감축의 최종 가치에 대한 약속입니다.

reduce<T>((previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T, T, Pick<ArrayOptions, "signal">)

function reduce<T>(fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial: T, options?: Pick<ArrayOptions, "signal">): Promise<T>

매개 변수

fn

(previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T

initial

T

options

Pick<ArrayOptions, "signal">

반품

Promise<T>

removeListener("close", () => void)

function removeListener(event: "close", listener: () => void): Readable

매개 변수

event

"close"

listener

() => void

반품

Readable

removeListener("data", (chunk: any) => void)

function removeListener(event: "data", listener: (chunk: any) => void): Readable

매개 변수

event

"data"

listener

(chunk: any) => void

반품

Readable

removeListener("end", () => void)

function removeListener(event: "end", listener: () => void): Readable

매개 변수

event

"end"

listener

() => void

반품

Readable

removeListener("error", (err: Error) => void)

function removeListener(event: "error", listener: (err: Error) => void): Readable

매개 변수

event

"error"

listener

(err: Error) => void

반품

Readable

removeListener("pause", () => void)

function removeListener(event: "pause", listener: () => void): Readable

매개 변수

event

"pause"

listener

() => void

반품

Readable

removeListener("readable", () => void)

function removeListener(event: "readable", listener: () => void): Readable

매개 변수

event

"readable"

listener

() => void

반품

Readable

removeListener("resume", () => void)

function removeListener(event: "resume", listener: () => void): Readable

매개 변수

event

"resume"

listener

() => void

반품

Readable

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

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

매개 변수

event

string | symbol

listener

(args: any[]) => void

반품

Readable

resume()

이 readable.resume() 방법은 명시적으로 일시정지된 Readable 스트림이 이벤트를 다시 방출 'data' 하게 하여 스트림을 흐름 모드로 전환하게 합니다.

이 readable.resume() 방법은 실제로 데이터를 처리하지 않고도 스트림의 데이터를 완전히 소비할 수 있습니다:

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

readable.resume() 이벤트 리스너가 'readable' 있으면 이 메서드는 효과가 없습니다.

function resume(): Readable

반품

Readable

setEncoding(BufferEncoding)

이 메서드는 readable.setEncoding() 스트림에서 Readable 읽는 데이터의 문자 인코딩을 설정합니다.

기본적으로 인코딩은 할당되지 않으며 스트림 데이터는 객체로 Buffer 반환됩니다. 인코딩을 설정하면 스트림 데이터가 객체가 아닌 Buffer 지정된 인코딩의 문자열로 반환됩니다. 예를 들어, 호출 readable.setEncoding('utf8') 하면 출력 데이터가 UTF-8 데이터로 해석되어 문자열로 전달됩니다. 호출하면 readable.setEncoding('hex') 데이터가 16진수 문자열 형식으로 인코딩됩니다.

스트림은 Readable 단순히 객체로 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

매개 변수

encoding

BufferEncoding

사용할 인코딩입니다.

반품

Readable

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

이 방법은 스트림 내 각 청크에서 Array.prototype.some을 호출하여 기다리는 반환값(또는 진리 값)이 될 때까지 호출하는 것과 유사 true 합니다. 청크 ed 반환값에 대한 await 호출이 진리가 되면, 스트림은 파괴되고 약속은 로 이루어집니다.true 만약 청크에 대한 fn 호출이 진리값(truthy value)을 반환하지 않으면, 약속은 로 충족 false됩니다.

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

매개 변수

fn

(data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>

스트림의 각 청크를 호출하는 함수입니다. 비동기 동기 여부 여부.

options

ArrayOptions

반품

Promise<boolean>

fn이 적어도 한 청크에 대해 진실값을 반환하는지 평가하는 true 약속입니다.

take(number, Pick<ArrayOptions, "signal">)

이 방법은 첫 번째 제한 청크를 가진 새로운 스트림을 반환합니다.

function take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable

매개 변수

limit

number

읽을 수 있는 것에서 추출할 청크 수.

options

Pick<ArrayOptions, "signal">

반품

Readable

제한 청크가 포함된 스트림.

toArray(Pick<ArrayOptions, "signal">)

이 방법은 스트림의 내용을 쉽게 얻을 수 있게 해줍니다.

이 방법은 전체 스트림을 메모리에 읽기 때문에 스트림의 이점을 상쇄합니다. 상호운용성과 편의성을 위해 설계된 것이지, 스트림을 소비하는 주된 방법이 아닙니다.

function toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>

매개 변수

options

Pick<ArrayOptions, "signal">

반품

Promise<any[]>

스트림의 내용을 포함하는 배열을 포함하는 약속입니다.

toWeb(Readable, { strategy?: QueuingStrategy<any> })

. 에서 웹 ReadableStreamReadable을 생성하는 유틸리티 방법

static function toWeb(streamReadable: Readable, options?: { strategy?: QueuingStrategy<any> }): ReadableStream<any>

매개 변수

streamReadable

Readable

options

{ strategy?: QueuingStrategy<any> }

반품

ReadableStream<any>

unpipe(WritableStream)

readable.unpipe() 이 방법은 Writable 방식으로 이전에 부착된 물줄기를 분리하는 방식입니다.

만약 이 destination 명시되지 않으면 모든 파이프가 분리됩니다.

만약 가 destination 지정되었지만 파이프가 설정되어 있지 않으면, 메서드는 아무런 동작을 하지 않습니다.

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

매개 변수

destination

WritableStream

언파이프할 특정 스트림 선택

반품

Readable

unshift(any, BufferEncoding)

로 chunk 패스하면 null 스트림의 끝(EOF)을 알리고, 와 동일readable.push(null)하게 동작하며, 그 이후에는 더 이상 데이터를 쓸 수 없습니다. EOF 신호는 버퍼 끝에 배치되며, 버퍼된 데이터는 여전히 플러싱됩니다.

이 readable.unshift() 방법은 데이터 덩어리를 내부 버퍼로 다시 밀어냅니다. 이는 스트림이 소스에서 낙관적으로 가져온 데이터를 "소모 해제"해야 하는 특정 상황에서 유용합니다.

stream.unshift(chunk) 이벤트가 'end' 발생한 후에는 메서드를 호출할 수 없으며, 그렇지 않으면 런타임 오류가 발생합니다.

자주 사용하는 stream.unshift() 개발자들은 스트림 사용 Transform 으로 전환하는 것을 고려해야 합니다. 자세한 내용은 섹션을 API for stream implementers 참조하세요.

// 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;
    }
  }
}

푸시와 달리, 스트림 stream.unshift(chunk) 의 내부 읽기 상태를 초기화하여 읽기 과정을 종료하지 않습니다. 이는 읽기 중(즉, readable.unshift() 구현 내 사용자 지정 스트림에서) 호출될 경우 예상치 못한 결과를 초래할 수 있습니다. 호출 readable.unshift() 후 즉시 푸시 를 하면 읽기 상태가 적절히 초기화되지만, 읽기 수행 중에는 호출을 피 readable.unshift() 하는 것이 가장 좋습니다.

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

매개 변수

chunk

any

데이터 덩어리를 읽기 대기열로 옮기는 것. 객체 모드에서 동작하지 않는 스트림의 경우, chunk {string}, {Buffer}, {TypedArray}, {DataView} 또는 null. 객체 모드 스트림의 경우, 는 chunk 어떤 자바스크립트 값이든 될 수 있습니다.

encoding

BufferEncoding

문자열 청크의 인코딩. 또는 와 같이 Buffer'utf8'유효 'ascii' 한 인코딩이어야 합니다.

wrap(ReadableStream)

Node.js 0.10 이전에는 스트림즈가 현재 정의된 전체 node:stream 모듈 API를 구현하지 않았습니다. (자세한 내용은 참고하세요 Compatibility .)

이벤트를 'data' 방출하고 일 시정지 메서드가 자문 전용 메서드인 오래된 Node.js 라이브러리를 사용할 때, 이 readable.wrap() 메서드를 사용해 기존 스트림을 데이터 소스로 사용하는 스트림을 Readable 생성할 수 있습니다.

이 방법은 거의 사용할 필요가 readable.wrap() 없지만, 오래된 Node.js 애플리케이션 및 라이브러리와의 상호작용을 편리하게 하기 위해 제공되었습니다.

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

매개 변수

stream

ReadableStream

"구식" 읽기 쉬운 스트림

반품

Readable

[asyncDispose]()

와 통화 readable.destroy()AbortError 하고 스트림이 끝나면 이행되는 약속을 반환합니다.

function [asyncDispose](): Promise<void>

반품

Promise<void>

[asyncIterator]()

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

반품

AsyncIterator<any, any, any>

상속된 메서드 세부 정보

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

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

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

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

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

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

매개 변수

signal

AbortSignal

resource

(event: Event) => void

반품

Disposable

청취자를 제거하는 abort 일회용 제품.

상속됨 Stream.addAbortListener

compose<T>(T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, { signal: AbortSignal })

function compose<T>(stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, options?: { signal: AbortSignal }): T

매개 변수

stream

T | ComposeFnParam | Iterable<T> | AsyncIterable<T>

options

{ signal: AbortSignal }

반품

T

상속받은 Stream.compose

eventNames()

이미터가 수신기를 등록한 이벤트를 나열하는 배열을 반환합니다. 배열의 값은 문자열 또는 Symbol.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

반품

(string | symbol)[]

상속된 곳 Stream.eventNames(스트림.eventNames)

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

eventName이벤트에 대한 수신기 배열의 복사본을 반환합니다.

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

s에 대해 EventTarget이벤트 타겟에 대해 이벤트 청취자를 얻는 유일한 방법입니다. 이는 디버깅 및 진단 목적으로 유용합니다.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

매개 변수

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

반품

Function[]

상속받은 Stream.getEvent청취자

getMaxListeners()

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

function getMaxListeners(): number

반품

number

상속된 곳 Stream.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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

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

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

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

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

매개 변수

emitter

EventEmitter<DefaultEventMap> | EventTarget

반품

number

상속된 곳 Stream.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

경고

이 API는 이제 사용되지 않습니다.

Since v3.2.0 - Use listenerCount instead.

주어진 eventName 에 등록 emitter된 리스터 수를 반환하는 클래스 메서드입니다.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

매개 변수

emitter

EventEmitter<DefaultEventMap>

쿼리할 방출기

eventName

string | symbol

이벤트 이름

반품

number

상속받은 Stream.listenerCount

listenerCount<K>(string | symbol, Function)

eventName이벤트를 수신 대기하는 수신기 수를 반환합니다. listener 제공된 경우 수신기가 이벤트 수신기 목록에서 발견된 횟수를 반환합니다.

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

매개 변수

eventName

string | symbol

수신 대기 중인 이벤트의 이름입니다.

listener

Function

이벤트 처리기 함수

반품

number

상속받은 Stream.listenerCount

listeners<K>(string | symbol)

eventName이벤트에 대한 수신기 배열의 복사본을 반환합니다.

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

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

매개 변수

eventName

string | symbol

반품

Function[]

상속받은 스트림. 리스너

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

emitter.removeListener()의 별칭입니다.

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

매개 변수

eventName

string | symbol

listener

(args: any[]) => void

반품

Readable

상속됨 스트림.오프

on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions)

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

const ee = new EventEmitter();

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

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

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

A AbortSignal 는 이벤트 대기 취소에 사용할 수 있습니다:

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

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

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

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

반복을 종료할 이벤트 이름 배열을 지정하는 옵션을 사용 close 하세요:

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

const ee = new EventEmitter();

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

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

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

매개 변수

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

반품

AsyncIterator<any[], any, any>

이 AsyncIterator 판은 다음에 의해 방출되는 사건들을 반복하는 eventName 것이다. emitter

상속됨 Stream.on

on(EventTarget, string, StaticEventEmitterIteratorOptions)

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

매개 변수

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

반품

AsyncIterator<any[], any, any>

상속됨 Stream.on

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

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

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

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

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

이벤트 특별 처리 'error' 는 다음 이벤트를 기다리는 경우에만 events.once() 사용됩니다. 만약 events.once() 가 '이벤트 자체를error' 기다리는 데 사용된다면, 특별한 처리 없이 다른 종류의 이벤트와 동일하게 취급됩니다:

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

이벤트 AbortSignal 를 기다리는 것을 취소하는 데 사용할 수 있습니다:

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

매개 변수

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

반품

Promise<any[]>

상속받은 스트림. 한 번

once(EventTarget, string, StaticEventEmitterOptions)

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

매개 변수

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

반품

Promise<any[]>

상속받은 스트림. 한 번

pipe<T>(T, { end?: boolean })

function pipe<T>(destination: T, options?: { end?: boolean }): T

매개 변수

destination

T

options

{ end?: boolean }

반품

T

상속된 곳 스트림.파이프

rawListeners<K>(string | symbol)

래퍼(예: eventName만든 래퍼)를 포함하여 .once()이벤트에 대한 수신기 배열의 복사본을 반환합니다.

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

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

매개 변수

eventName

string | symbol

반품

Function[]

상속받은 Stream.raw청취자들

removeAllListeners(string | symbol)

모든 수신기 또는 지정된 eventName제거합니다.

특히 다른 구성 요소 또는 모듈(예: 소켓 또는 파일 스트림)에서 EventEmitter 인스턴스를 만든 경우 코드의 다른 위치에 추가된 수신기를 제거하는 것은 잘못된 방법입니다.

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

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

매개 변수

eventName

string | symbol

반품

Readable

상속됨 스트리밍.삭제 모든 청취자

setMaxListeners(number)

기본적으로 EventEmitter특정 이벤트에 대해 10 개 이상의 수신기가 추가되면 경고를 출력합니다. 이는 메모리 누수 찾기에 도움이 되는 유용한 기본값입니다. emitter.setMaxListeners() 메서드를 사용하면 이 특정 EventEmitter 인스턴스에 대한 제한을 수정할 수 있습니다. 값을 Infinity(또는 0)로 설정하여 무제한 수신기를 나타낼 수 있습니다.

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

function setMaxListeners(n: number): Readable

매개 변수

n

number

반품

Readable

상속된 곳 Stream.setMaxListeners

setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[])

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

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

매개 변수

n

number

음수가 아닌 숫자입니다. 이벤트별 EventTarget 최대 청취자 수.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

{EventTarget} 또는 {EventEmitter} 인스턴스가 0개 이상입니다. 만약 지정이 없으면, n 는 새로 생성된 모든 {EventTarget}과 {EventEmitter} 객체의 기본 최대 값으로 설정됩니다.

상속된 곳 Stream.setMaxListeners

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

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

매개 변수

error

Error

event

string | symbol

args

AnyRest

상속된 곳 Stream.__@captureRejectionSymbol@184