- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
Node.js v16.20.0 文档
- Node.js v16.20.0
-
目录
- 流
- 本文档的组织
- 流的类型
- 流消费者的 API
- 可写流
- 类:
stream.Writable
- 事件:
'close'
- 事件:
'drain'
- 事件:
'error'
- 事件:
'finish'
- 事件:
'pipe'
- 事件:
'unpipe'
writable.cork()
writable.destroy([error])
writable.destroyed
writable.end([chunk[, encoding]][, callback])
writable.setDefaultEncoding(encoding)
writable.uncork()
writable.writable
writable.writableAborted
writable.writableEnded
writable.writableCorked
writable.writableFinished
writable.writableHighWaterMark
writable.writableLength
writable.writableNeedDrain
writable.writableObjectMode
writable.write(chunk[, encoding][, callback])
- 事件:
- 类:
- 可读流
- 两种读取模式
- 三种状态
- 选择一种 API 风格
- 类:
stream.Readable
- 事件:
'close'
- 事件:
'data'
- 事件:
'end'
- 事件:
'error'
- 事件:
'pause'
- 事件:
'readable'
- 事件:
'resume'
readable.destroy([error])
readable.destroyed
readable.isPaused()
readable.pause()
readable.pipe(destination[, options])
readable.read([size])
readable.readable
readable.readableAborted
readable.readableDidRead
readable.readableEncoding
readable.readableEnded
readable.readableFlowing
readable.readableHighWaterMark
readable.readableLength
readable.readableObjectMode
readable.resume()
readable.setEncoding(encoding)
readable.unpipe([destination])
readable.unshift(chunk[, encoding])
readable.wrap(stream)
readable[Symbol.asyncIterator]()
readable.iterator([options])
readable.map(fn[, options])
readable.filter(fn[, options])
readable.forEach(fn[, options])
readable.toArray([options])
readable.some(fn[, options])
readable.find(fn[, options])
readable.every(fn[, options])
readable.flatMap(fn[, options])
readable.drop(limit[, options])
readable.take(limit[, options])
readable.asIndexedPairs([options])
readable.reduce(fn[, initial[, options]])
- 事件:
- 双工和转换流
stream.finished(stream[, options], callback)
stream.pipeline(source[, ...transforms], destination, callback)
stream.pipeline(streams, callback)
stream.compose(...streams)
stream.Readable.from(iterable[, options])
stream.Readable.isDisturbed(stream)
stream.isErrored(stream)
stream.isReadable(stream)
stream.Readable.toWeb(streamReadable)
stream.Writable.fromWeb(writableStream[, options])
stream.Writable.toWeb(streamWritable)
stream.Duplex.from(src)
stream.addAbortSignal(signal, stream)
- 可写流
- 流实现者的 API
- 补充注意
- 流
-
导航
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
- 其他版本
流#
¥Stream
¥Stability: 2 - Stable
源代码: lib/stream.js
流是用于在 Node.js 中处理流数据的抽象接口。node:stream
模块提供了用于实现流接口的 API。
¥A stream is an abstract interface for working with streaming data in Node.js.
The node:stream
module provides an API for implementing the stream interface.
Node.js 提供了许多流对象。例如,向 HTTP 服务器请求 和 process.stdout
都是流实例。
¥There are many stream objects provided by Node.js. For instance, a
request to an HTTP server and process.stdout
are both stream instances.
流可以是可读的、可写的、或两者兼而有之。所有的流都是 EventEmitter
的实例。
¥Streams can be readable, writable, or both. All streams are instances of
EventEmitter
.
要访问 node:stream
模块:
¥To access the node:stream
module:
const stream = require('node:stream');
node:stream
模块对于创建新类型的流实例很有用。通常不需要使用 node:stream
模块来消费流。
¥The node:stream
module is useful for creating new types of stream instances.
It is usually not necessary to use the node:stream
module to consume streams.
本文档的组织#
¥Organization of this document
本文档包含两个主要章节和第三章节的注意事项。第一章节描述了如何在应用中使用现有的流。第二章节描述了如何创建新类型的流。
¥This document contains two primary sections and a third section for notes. The first section explains how to use existing streams within an application. The second section explains how to create new types of streams.
流的类型#
¥Types of streams
Node.js 中有四种基本的流类型:
¥There are four fundamental stream types within Node.js:
-
Writable
:可以写入数据的流(例如,fs.createWriteStream()
)。¥
Writable
: streams to which data can be written (for example,fs.createWriteStream()
). -
Readable
:可以从中读取数据的流(例如,fs.createReadStream()
)。¥
Readable
: streams from which data can be read (for example,fs.createReadStream()
). -
Duplex
:Readable
和Writable
的流(例如,net.Socket
)。¥
Duplex
: streams that are bothReadable
andWritable
(for example,net.Socket
). -
Transform
:可以在写入和读取数据时修改或转换数据的Duplex
流(例如,zlib.createDeflate()
)。¥
Transform
:Duplex
streams that can modify or transform the data as it is written and read (for example,zlib.createDeflate()
).
此外,此模块还包括实用函数 stream.pipeline()
、stream.finished()
、stream.Readable.from()
和 stream.addAbortSignal()
。
¥Additionally, this module includes the utility functions
stream.pipeline()
, stream.finished()
, stream.Readable.from()
and stream.addAbortSignal()
.
流 Promise API#
¥Streams Promises API
stream/promises
API 为返回 Promise
对象(而不是使用回调)的流提供了一组替代的异步实用函数。API 可通过 require('node:stream/promises')
或 require('node:stream').promises
访问。
¥The stream/promises
API provides an alternative set of asynchronous utility
functions for streams that return Promise
objects rather than using
callbacks. The API is accessible via require('node:stream/promises')
or require('node:stream').promises
.
对象模式#
¥Object mode
Node.js API 创建的所有流都只对字符串和 Buffer
(或 Uint8Array
)对象进行操作。但是,流的实现可以使用其他类型的 JavaScript 值(除了 null
,它在流中具有特殊用途)。这样的流被认为在 "对象模式" 中运行。
¥All streams created by Node.js APIs operate exclusively on strings and Buffer
(or Uint8Array
) objects. It is possible, however, for stream implementations
to work with other types of JavaScript values (with the exception of null
,
which serves a special purpose within streams). Such streams are considered to
operate in "object mode".
流的实例在创建流时使用 objectMode
选项切换到对象模式。尝试将现有的流切换到对象模式是不安全的。
¥Stream instances are switched into object mode using the objectMode
option
when the stream is created. Attempting to switch an existing stream into
object mode is not safe.
缓冲#
¥Buffering
Writable
和 Readable
流都将数据存储在内部缓冲区中。
¥Both Writable
and Readable
streams will store data in an internal
buffer.
可能缓冲的数据量取决于传给流的构造函数的 highWaterMark
选项。对于普通流,highWaterMark
选项指定 总字节数。对于在对象模式下操作的流,highWaterMark
指定对象的总数。
¥The amount of data potentially buffered depends on the highWaterMark
option
passed into the stream's constructor. For normal streams, the highWaterMark
option specifies a total number of bytes. For streams operating
in object mode, the highWaterMark
specifies a total number of objects.
当实现调用 stream.push(chunk)
时,数据缓存在 Readable
流中。如果流的消费者没有调用 stream.read()
,则数据会一直驻留在内部队列中,直到被消费。
¥Data is buffered in Readable
streams when the implementation calls
stream.push(chunk)
. If the consumer of the Stream does not
call stream.read()
, the data will sit in the internal
queue until it is consumed.
一旦内部读取缓冲区的总大小达到 highWaterMark
指定的阈值,则流将暂时停止从底层资源读取数据,直到可以消费当前缓冲的数据(也就是,流将停止调用内部的用于填充读取缓冲区 readable._read()
方法)。
¥Once the total size of the internal read buffer reaches the threshold specified
by highWaterMark
, the stream will temporarily stop reading data from the
underlying resource until the data currently buffered can be consumed (that is,
the stream will stop calling the internal readable._read()
method that is
used to fill the read buffer).
当重复调用 writable.write(chunk)
方法时,数据会缓存在 Writable
流中。虽然内部的写入缓冲区的总大小低于 highWaterMark
设置的阈值,但对 writable.write()
的调用将返回 true
。一旦内部缓冲区的大小达到或超过 highWaterMark
,则将返回 false
。
¥Data is buffered in Writable
streams when the
writable.write(chunk)
method is called repeatedly. While the
total size of the internal write buffer is below the threshold set by
highWaterMark
, calls to writable.write()
will return true
. Once
the size of the internal buffer reaches or exceeds the highWaterMark
, false
will be returned.
stream
API 的一个关键目标,尤其是 stream.pipe()
方法,是将数据缓冲限制在可接受的水平,以便不同速度的来源和目标不会压倒可用内存。
¥A key goal of the stream
API, particularly the stream.pipe()
method,
is to limit the buffering of data to acceptable levels such that sources and
destinations of differing speeds will not overwhelm the available memory.
highWaterMark
选项是一个阈值,而不是限制:它规定了流在停止请求更多数据之前缓冲的数据量。它通常不强制执行严格的内存限制。特定的流实现可能会选择实现更严格的限制,但这样做是可选的。
¥The highWaterMark
option is a threshold, not a limit: it dictates the amount
of data that a stream buffers before it stops asking for more data. It does not
enforce a strict memory limitation in general. Specific stream implementations
may choose to enforce stricter limits but doing so is optional.
因为 Duplex
和 Transform
流都是 Readable
和 Writable
,所以每个都维护两个独立的内部缓冲区,用于读取和写入,允许每一方独立于另一方操作,同时保持适当和高效的数据流。例如,net.Socket
实例是 Duplex
流,其 Readable
端允许使用从套接字接收的数据,其 Writable
端允许将数据写入套接字。因为数据可能以比接收数据更快或更慢的速度写入套接字,所以每一端都应该独立于另一端进行操作(和缓冲)。
¥Because Duplex
and Transform
streams are both Readable
and
Writable
, each maintains two separate internal buffers used for reading and
writing, allowing each side to operate independently of the other while
maintaining an appropriate and efficient flow of data. For example,
net.Socket
instances are Duplex
streams whose Readable
side allows
consumption of data received from the socket and whose Writable
side allows
writing data to the socket. Because data may be written to the socket at a
faster or slower rate than data is received, each side should
operate (and buffer) independently of the other.
内部缓冲的机制是内部的实现细节,可能随时更改。但是,对于某些高级实现,可以使用 writable.writableBuffer
或 readable.readableBuffer
检索内部的缓冲区。不鼓励使用这些未记录的属性。
¥The mechanics of the internal buffering are an internal implementation detail
and may be changed at any time. However, for certain advanced implementations,
the internal buffers can be retrieved using writable.writableBuffer
or
readable.readableBuffer
. Use of these undocumented properties is discouraged.
流消费者的 API#
¥API for stream consumers
几乎所有的 Node.js 应用,无论多么简单,都以某种方式使用流。以下是在实现 HTTP 服务器的 Node.js 应用中使用流的示例:
¥Almost all Node.js applications, no matter how simple, use streams in some manner. The following is an example of using streams in a Node.js application that implements an HTTP server:
const http = require('node:http');
const server = http.createServer((req, res) => {
// `req` is an http.IncomingMessage, which is a readable stream.
// `res` is an http.ServerResponse, which is a writable stream.
let body = '';
// Get the data as utf8 strings.
// If an encoding is not set, Buffer objects will be received.
req.setEncoding('utf8');
// Readable streams emit 'data' events once a listener is added.
req.on('data', (chunk) => {
body += chunk;
});
// The 'end' event indicates that the entire body has been received.
req.on('end', () => {
try {
const data = JSON.parse(body);
// Write back something interesting to the user:
res.write(typeof data);
res.end();
} catch (er) {
// uh oh! bad json!
res.statusCode = 400;
return res.end(`error: ${er.message}`);
}
});
});
server.listen(1337);
// $ curl localhost:1337 -d "{}"
// object
// $ curl localhost:1337 -d "\"foo\""
// string
// $ curl localhost:1337 -d "not json"
// error: Unexpected token o in JSON at position 1
Writable
流(例如示例中的 res
)暴露了用于将数据写入流的方法,例如 write()
和 end()
。
¥Writable
streams (such as res
in the example) expose methods such as
write()
and end()
that are used to write data onto the stream.
当数据可从流中读取时,Readable
流使用 EventEmitter
API 通知应用代码。可以通过多种方式从流中读取可用数据。
¥Readable
streams use the EventEmitter
API for notifying application
code when data is available to be read off the stream. That available data can
be read from the stream in multiple ways.
Writable
和 Readable
流都以各种方式使用 EventEmitter
API 来传达流的当前状态。
¥Both Writable
and Readable
streams use the EventEmitter
API in
various ways to communicate the current state of the stream.
Duplex
和 Transform
流都是 Writable
和 Readable
。
¥Duplex
and Transform
streams are both Writable
and
Readable
.
向流中写入数据或从流中消费数据的应用不需要直接实现流的接口,并且通常没有理由调用 require('node:stream')
。
¥Applications that are either writing data to or consuming data from a stream
are not required to implement the stream interfaces directly and will generally
have no reason to call require('node:stream')
.
希望实现新型流的开发者应参考 流实现者的 API 部分。
¥Developers wishing to implement new types of streams should refer to the section API for stream implementers.
可写流#
¥Writable streams
可写流是数据写入目标的抽象。
¥Writable streams are an abstraction for a destination to which data is written.
Writable
流的示例包括:
¥Examples of Writable
streams include:
其中一些示例实际上是实现 Writable
接口的 Duplex
流。
¥Some of these examples are actually Duplex
streams that implement the
Writable
interface.
所有的 Writable
流都实现了 stream.Writable
类定义的接口。
¥All Writable
streams implement the interface defined by the
stream.Writable
class.
虽然 Writable
流的特定实例可能以各种方式不同,但所有的 Writable
流都遵循相同的基本使用模式,如下例所示:
¥While specific instances of Writable
streams may differ in various ways,
all Writable
streams follow the same fundamental usage pattern as illustrated
in the example below:
const myStream = getWritableStreamSomehow();
myStream.write('some data');
myStream.write('some more data');
myStream.end('done writing data');
类:stream.Writable
#
¥Class: stream.Writable
事件:'close'
#
¥Event: 'close'
当流及其任何底层资源(例如文件描述符)已关闭时,则会触发 'close'
事件。该事件表明将不再触发更多事件,并且不会发生进一步的计算。
¥The 'close'
event is emitted when the stream and any of its underlying
resources (a file descriptor, for example) have been closed. The event indicates
that no more events will be emitted, and no further computation will occur.
如果 Writable
流是使用 emitClose
选项创建的,则始终会触发 'close'
事件。
¥A Writable
stream will always emit the 'close'
event if it is
created with the emitClose
option.
事件:'drain'
#
¥Event: 'drain'
如果对 stream.write(chunk)
的调用返回 false
,则 'drain'
事件将在适合继续将数据写入流时触发。
¥If a call to stream.write(chunk)
returns false
, the
'drain'
event will be emitted when it is appropriate to resume writing data
to the stream.
// Write the data to the supplied writable stream one million times.
// Be attentive to back-pressure.
function writeOneMillionTimes(writer, data, encoding, callback) {
let i = 1000000;
write();
function write() {
let ok = true;
do {
i--;
if (i === 0) {
// Last time!
writer.write(data, encoding, callback);
} else {
// See if we should continue, or wait.
// Don't pass the callback, because we're not done yet.
ok = writer.write(data, encoding);
}
} while (i > 0 && ok);
if (i > 0) {
// Had to stop early!
// Write some more once it drains.
writer.once('drain', write);
}
}
}
事件:'error'
#
¥Event: 'error'
如果在写入或管道数据时发生错误,则会触发 'error'
事件。监听器回调在调用时传入单个 Error
参数。
¥The 'error'
event is emitted if an error occurred while writing or piping
data. The listener callback is passed a single Error
argument when called.
除非在创建流时将 autoDestroy
选项设置为 false
,否则当触发 'error'
事件时将关闭流。
¥The stream is closed when the 'error'
event is emitted unless the
autoDestroy
option was set to false
when creating the
stream.
在 'error'
之后,除 'close'
之外不应再触发其他事件(包括 'error'
事件)。
¥After 'error'
, no further events other than 'close'
should be emitted
(including 'error'
events).
事件:'finish'
#
¥Event: 'finish'
在调用 stream.end()
方法之后,并且所有数据都已刷新到底层系统,则触发 'finish'
事件。
¥The 'finish'
event is emitted after the stream.end()
method
has been called, and all data has been flushed to the underlying system.
const writer = getWritableStreamSomehow();
for (let i = 0; i < 100; i++) {
writer.write(`hello, #${i}!\n`);
}
writer.on('finish', () => {
console.log('All writes are now complete.');
});
writer.end('This is the end\n');
事件:'pipe'
#
¥Event: 'pipe'
-
src
<stream.Readable> 通过管道传输到此可写的源流¥
src
<stream.Readable> source stream that is piping to this writable
当在可读流上调用 stream.pipe()
方法将此可写流添加到其目标集时,则触发 'pipe'
事件。
¥The 'pipe'
event is emitted when the stream.pipe()
method is called on
a readable stream, adding this writable to its set of destinations.
const writer = getWritableStreamSomehow();
const reader = getReadableStreamSomehow();
writer.on('pipe', (src) => {
console.log('Something is piping into the writer.');
assert.equal(src, reader);
});
reader.pipe(writer);
事件:'unpipe'
#
¥Event: 'unpipe'
-
src
<stream.Readable> unpiped 这个可写的源码流¥
src
<stream.Readable> The source stream that unpiped this writable
当在 Readable
流上调用 stream.unpipe()
方法时,则会触发 'unpipe'
事件,从其目标集合中删除此 Writable
。
¥The 'unpipe'
event is emitted when the stream.unpipe()
method is called
on a Readable
stream, removing this Writable
from its set of
destinations.
当 Readable
流管道进入它时,如果此 Writable
流触发错误,则这也会触发。
¥This is also emitted in case this Writable
stream emits an error when a
Readable
stream pipes into it.
const writer = getWritableStreamSomehow();
const reader = getReadableStreamSomehow();
writer.on('unpipe', (src) => {
console.log('Something has stopped piping into the writer.');
assert.equal(src, reader);
});
reader.pipe(writer);
reader.unpipe(writer);
writable.cork()
#
writable.cork()
方法强制所有写入的数据都缓存在内存中。当调用 stream.uncork()
或 stream.end()
方法时,缓冲的数据将被刷新。
¥The writable.cork()
method forces all written data to be buffered in memory.
The buffered data will be flushed when either the stream.uncork()
or
stream.end()
methods are called.
writable.cork()
的主要目的是适应将几个小块快速连续写入流的情况。writable.cork()
不是立即将它们转发到底层目标,而是缓冲所有块,直到 writable.uncork()
被调用,如果存在,writable.uncork()
会将它们全部传给 writable._writev()
。这可以防止在等待处理第一个小块时正在缓冲数据的行头阻塞情况。但是,在不实现 writable._writev()
的情况下使用 writable.cork()
可能会对吞吐量产生不利影响。
¥The primary intent of writable.cork()
is to accommodate a situation in which
several small chunks are written to the stream in rapid succession. Instead of
immediately forwarding them to the underlying destination, writable.cork()
buffers all the chunks until writable.uncork()
is called, which will pass them
all to writable._writev()
, if present. This prevents a head-of-line blocking
situation where data is being buffered while waiting for the first small chunk
to be processed. However, use of writable.cork()
without implementing
writable._writev()
may have an adverse effect on throughput.
也可以看看:writable.uncork()
, writable._writev()
.
¥See also: writable.uncork()
, writable._writev()
.
writable.destroy([error])
#
-
error
<Error> 可选,与'error'
事件一起触发的错误。¥
error
<Error> Optional, an error to emit with'error'
event. -
返回:<this>
¥Returns: <this>
销毁流可选地触发 'error'
事件,并且触发 'close'
事件(除非 emitClose
设置为 false
)。在此调用之后,则可写流已结束,随后对 write()
或 end()
的调用将导致 ERR_STREAM_DESTROYED
错误。这是销毁流的销毁性和直接的方式。先前对 write()
的调用可能没有排空,并且可能触发 ERR_STREAM_DESTROYED
错误。如果数据应该在关闭之前刷新,或者在销毁流之前等待 'drain'
事件,则使用 end()
而不是销毁。
¥Destroy the stream. Optionally emit an 'error'
event, and emit a 'close'
event (unless emitClose
is set to false
). After this call, the writable
stream has ended and subsequent calls to write()
or end()
will result in
an ERR_STREAM_DESTROYED
error.
This is a destructive and immediate way to destroy a stream. Previous calls to
write()
may not have drained, and may trigger an ERR_STREAM_DESTROYED
error.
Use end()
instead of destroy if data should flush before close, or wait for
the 'drain'
event before destroying the stream.
const { Writable } = require('node:stream');
const myStream = new Writable();
const fooErr = new Error('foo error');
myStream.destroy(fooErr);
myStream.on('error', (fooErr) => console.error(fooErr.message)); // foo error
const { Writable } = require('node:stream');
const myStream = new Writable();
myStream.destroy();
myStream.on('error', function wontHappen() {});
const { Writable } = require('node:stream');
const myStream = new Writable();
myStream.destroy();
myStream.write('foo', (error) => console.error(error.code));
// ERR_STREAM_DESTROYED
一旦 destroy()
被调用,任何进一步的调用都将是空操作,除了来自 _destroy()
的其他错误可能不会作为 'error'
触发。
¥Once destroy()
has been called any further calls will be a no-op and no
further errors except from _destroy()
may be emitted as 'error'
.
实现者不应覆盖此方法,而应实现 writable._destroy()
。
¥Implementors should not override this method,
but instead implement writable._destroy()
.
writable.destroyed
#
在调用 writable.destroy()
之后是 true
。
¥Is true
after writable.destroy()
has been called.
const { Writable } = require('node:stream');
const myStream = new Writable();
console.log(myStream.destroyed); // false
myStream.destroy();
console.log(myStream.destroyed); // true
writable.end([chunk[, encoding]][, callback])
#
-
chunk
<string> | <Buffer> | <Uint8Array> | <any> 可选的要写入的数据。对于不在对象模式下操作的流,chunk
必须是字符串、Buffer
或Uint8Array
。对于对象模式的流,chunk
可以是除null
之外的任何 JavaScript 值。¥
chunk
<string> | <Buffer> | <Uint8Array> | <any> Optional data to write. For streams not operating in object mode,chunk
must be a string,Buffer
orUint8Array
. For object mode streams,chunk
may be any JavaScript value other thannull
. -
encoding
<string>chunk
为字符串时的编码¥
encoding
<string> The encoding ifchunk
is a string -
callback
<Function> 流结束时的回调。¥
callback
<Function> Callback for when the stream is finished. -
返回:<this>
¥Returns: <this>
调用 writable.end()
方法表示不再有数据写入 Writable
。可选的 chunk
和 encoding
参数允许在关闭流之前立即写入最后一个额外的数据块。
¥Calling the writable.end()
method signals that no more data will be written
to the Writable
. The optional chunk
and encoding
arguments allow one
final additional chunk of data to be written immediately before closing the
stream.
在调用 stream.end()
之后调用 stream.write()
方法将引发错误。
¥Calling the stream.write()
method after calling
stream.end()
will raise an error.
// Write 'hello, ' and then end with 'world!'.
const fs = require('node:fs');
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!
writable.setDefaultEncoding(encoding)
#
writable.setDefaultEncoding()
方法为 Writable
流设置默认的 encoding
。
¥The writable.setDefaultEncoding()
method sets the default encoding
for a
Writable
stream.
writable.uncork()
#
writable.uncork()
方法会刷新自调用 stream.cork()
以来缓冲的所有数据。
¥The writable.uncork()
method flushes all data buffered since
stream.cork()
was called.
当使用 writable.cork()
和 writable.uncork()
管理写入流的缓冲时,使用 process.nextTick()
推迟对 writable.uncork()
的调用。这样做允许对在给定 Node.js 事件循环阶段中发生的所有 writable.write()
调用进行批处理。
¥When using writable.cork()
and writable.uncork()
to manage the buffering
of writes to a stream, defer calls to writable.uncork()
using
process.nextTick()
. Doing so allows batching of all
writable.write()
calls that occur within a given Node.js event loop phase.
stream.cork();
stream.write('some ');
stream.write('data ');
process.nextTick(() => stream.uncork());
如果在一个流上多次调用 writable.cork()
方法,则必须调用相同数量的 writable.uncork()
调用来刷新缓冲的数据。
¥If the writable.cork()
method is called multiple times on a stream, the
same number of calls to writable.uncork()
must be called to flush the buffered
data.
stream.cork();
stream.write('some ');
stream.cork();
stream.write('data ');
process.nextTick(() => {
stream.uncork();
// The data will not be flushed until uncork() is called a second time.
stream.uncork();
});
也可以看看:writable.cork()
。
¥See also: writable.cork()
.
writable.writable
#
如果调用 writable.write()
是安全的,则为 true
,这意味着流没有被销毁、错误或结束。
¥Is true
if it is safe to call writable.write()
, which means
the stream has not been destroyed, errored, or ended.
writable.writableAborted
#
¥Stability: 1 - Experimental
返回在触发 'finish'
之前流是被破销毁或出错。
¥Returns whether the stream was destroyed or errored before emitting 'finish'
.
writable.writableEnded
#
在调用 writable.end()
之后是 true
。此属性不指示数据是否已刷新,为此则使用 writable.writableFinished
代替。
¥Is true
after writable.end()
has been called. This property
does not indicate whether the data has been flushed, for this use
writable.writableFinished
instead.
writable.writableCorked
#
需要调用 writable.uncork()
以完全解开流的次数。
¥Number of times writable.uncork()
needs to be
called in order to fully uncork the stream.
writable.writableFinished
#
在触发 'finish'
事件之前立即设置为 true
。
¥Is set to true
immediately before the 'finish'
event is emitted.
writable.writableHighWaterMark
#
返回创建此 Writable
时传入的 highWaterMark
的值。
¥Return the value of highWaterMark
passed when creating this Writable
.
writable.writableLength
#
此属性包含队列中准备写入的字节数(或对象数)。该值提供有关 highWaterMark
状态的内省数据。
¥This property contains the number of bytes (or objects) in the queue
ready to be written. The value provides introspection data regarding
the status of the highWaterMark
.
writable.writableNeedDrain
#
如果流的缓冲区已满并且流将触发 'drain'
,则为 true
。
¥Is true
if the stream's buffer has been full and stream will emit 'drain'
.
writable.writableObjectMode
#
给定 Writable
流的属性 objectMode
的获取器。
¥Getter for the property objectMode
of a given Writable
stream.
writable.write(chunk[, encoding][, callback])
#
-
chunk
<string> | <Buffer> | <Uint8Array> | <any> 可选的要写入的数据。对于不在对象模式下操作的流,chunk
必须是字符串、Buffer
或Uint8Array
。对于对象模式的流,chunk
可以是除null
之外的任何 JavaScript 值。¥
chunk
<string> | <Buffer> | <Uint8Array> | <any> Optional data to write. For streams not operating in object mode,chunk
must be a string,Buffer
orUint8Array
. For object mode streams,chunk
may be any JavaScript value other thannull
. -
encoding
<string> | <null> 如果chunk
为字符串,则为编码。默认值:'utf8'
¥
encoding
<string> | <null> The encoding, ifchunk
is a string. Default:'utf8'
-
callback
<Function> 当刷新此数据块时的回调。¥
callback
<Function> Callback for when this chunk of data is flushed. -
返回:<boolean>
false
如果流希望调用代码在继续写入附加数据之前等待'drain'
事件触发;否则true
。¥Returns: <boolean>
false
if the stream wishes for the calling code to wait for the'drain'
event to be emitted before continuing to write additional data; otherwisetrue
.
writable.write()
方法将一些数据写入流,并在数据完全处理后调用提供的 callback
。如果发生错误,则 callback
将使用错误作为其第一个参数进行调用。callback
是异步地调用,并且在 'error'
触发之前。
¥The writable.write()
method writes some data to the stream, and calls the
supplied callback
once the data has been fully handled. If an error
occurs, the callback
will be called with the error as its
first argument. The callback
is called asynchronously and before 'error'
is
emitted.
如果在接纳 chunk
后,内部缓冲区小于当创建流时配置的 highWaterMark
,则返回值为 true
。如果返回 false
,则应停止进一步尝试将数据写入流,直到触发 'drain'
事件。
¥The return value is true
if the internal buffer is less than the
highWaterMark
configured when the stream was created after admitting chunk
.
If false
is returned, further attempts to write data to the stream should
stop until the 'drain'
event is emitted.
当流没有排空时,对 write()
的调用将缓冲 chunk
,并返回 false。一旦所有当前缓冲的块都被排空(操作系统接受交付),则将触发 'drain'
事件。一旦 write()
返回 false,则在 'drain'
事件触发之前不要写入更多块。虽然允许在未排空的流上调用 write()
,但 Node.js 将缓冲所有写入的块,直到出现最大内存使用量,此时它将无条件中止。即使在它中止之前,高内存使用量也会导致垃圾收集器性能不佳和高 RSS(通常不会释放回系统,即使在不再需要内存之后)。由于如果远程对等方不读取数据,TCP 套接字可能永远不会排空,因此写入未排空的套接字可能会导致可远程利用的漏洞。
¥While a stream is not draining, calls to write()
will buffer chunk
, and
return false. Once all currently buffered chunks are drained (accepted for
delivery by the operating system), the 'drain'
event will be emitted.
Once write()
returns false, do not write more chunks
until the 'drain'
event is emitted. While calling write()
on a stream that
is not draining is allowed, Node.js will buffer all written chunks until
maximum memory usage occurs, at which point it will abort unconditionally.
Even before it aborts, high memory usage will cause poor garbage collector
performance and high RSS (which is not typically released back to the system,
even after the memory is no longer required). Since TCP sockets may never
drain if the remote peer does not read the data, writing a socket that is
not draining may lead to a remotely exploitable vulnerability.
在流未排空时写入数据对于 Transform
来说尤其成问题,因为 Transform
流是默认暂停,直到它们被管道传输、或添加 'data'
或 'readable'
事件句柄。
¥Writing data while the stream is not draining is particularly
problematic for a Transform
, because the Transform
streams are paused
by default until they are piped or a 'data'
or 'readable'
event handler
is added.
如果要写入的数据可以按需生成或获取,则建议将逻辑封装成 Readable
并且使用 stream.pipe()
。但是,如果首选调用 write()
,则可以使用 'drain'
事件遵守背压并避免内存问题:
¥If the data to be written can be generated or fetched on demand, it is
recommended to encapsulate the logic into a Readable
and use
stream.pipe()
. However, if calling write()
is preferred, it is
possible to respect backpressure and avoid memory issues using the
'drain'
event:
function write(data, cb) {
if (!stream.write(data)) {
stream.once('drain', cb);
} else {
process.nextTick(cb);
}
}
// Wait for cb to be called before doing any other write.
write('hello', () => {
console.log('Write completed, do more writes now.');
});
对象模式下的 Writable
流将始终忽略 encoding
参数。
¥A Writable
stream in object mode will always ignore the encoding
argument.
可读流#
¥Readable streams
可读流是对消费数据源的抽象。
¥Readable streams are an abstraction for a source from which data is consumed.
Readable
流的示例包括:
¥Examples of Readable
streams include:
所有的 Readable
流都实现了 stream.Readable
类定义的接口。
¥All Readable
streams implement the interface defined by the
stream.Readable
class.
两种读取模式#
¥Two reading modes
Readable
流以两种模式之一有效运行:流动和暂停。这些模式与 对象模式 是分开的。Readable
流可以处于或不处于对象模式,无论其是处于流动模式还是暂停模式。
¥Readable
streams effectively operate in one of two modes: flowing and
paused. These modes are separate from object mode.
A Readable
stream can be in object mode or not, regardless of whether
it is in flowing mode or paused mode.
-
在流动模式下,数据会自动从底层系统读取,并通过
EventEmitter
接口使用事件尽快提供给应用。¥In flowing mode, data is read from the underlying system automatically and provided to an application as quickly as possible using events via the
EventEmitter
interface. -
在暂停模式下,必须显式调用
stream.read()
方法以从流中读取数据块。¥In paused mode, the
stream.read()
method must be called explicitly to read chunks of data from the stream.
所有的 Readable
流都以暂停模式开始,但可以通过以下方式之一切换到流动模式:
¥All Readable
streams begin in paused mode but can be switched to flowing
mode in one of the following ways:
-
添加
'data'
事件句柄。¥Adding a
'data'
event handler. -
调用
stream.resume()
方法。¥Calling the
stream.resume()
method. -
调用
stream.pipe()
方法将数据发送到Writable
。¥Calling the
stream.pipe()
method to send the data to aWritable
.
Readable
可以使用以下方法之一切换回暂停模式:
¥The Readable
can switch back to paused mode using one of the following:
-
如果没有管道目标,则通过调用
stream.pause()
方法。¥If there are no pipe destinations, by calling the
stream.pause()
method. -
如果有管道目标,则删除所有管道目标。可以通过调用
stream.unpipe()
方法删除多个管道目标。¥If there are pipe destinations, by removing all pipe destinations. Multiple pipe destinations may be removed by calling the
stream.unpipe()
method.
要记住的重要概念是,在提供消费或忽略该数据的机制之前,Readable
不会产生数据。如果消费机制被禁用或取消,Readable
将尝试停止生成数据。
¥The important concept to remember is that a Readable
will not generate data
until a mechanism for either consuming or ignoring that data is provided. If
the consuming mechanism is disabled or taken away, the Readable
will attempt
to stop generating the data.
出于向后兼容性的原因,删除 'data'
事件处理程序不会自动暂停流。此外,如果有管道目标,则调用 stream.pause()
将不能保证一旦这些目标耗尽并请求更多数据,流将保持暂停状态。
¥For backward compatibility reasons, removing 'data'
event handlers will
not automatically pause the stream. Also, if there are piped destinations,
then calling stream.pause()
will not guarantee that the
stream will remain paused once those destinations drain and ask for more data.
如果 Readable
切换到流动模式并且没有消费者可用于处理数据,则数据将被丢失。例如,当调用 readable.resume()
方法而没有绑定到 'data'
事件的监听器时,或者当从流中删除 'data'
事件句柄时,就会发生这种情况。
¥If a Readable
is switched into flowing mode and there are no consumers
available to handle the data, that data will be lost. This can occur, for
instance, when the readable.resume()
method is called without a listener
attached to the 'data'
event, or when a 'data'
event handler is removed
from the stream.
添加 'readable'
事件句柄会自动使流停止流动,并且必须通过 readable.read()
来消费数据。如果删除了 'readable'
事件句柄,则如果有 'data'
事件句柄,流将再次开始流动。
¥Adding a 'readable'
event handler automatically makes the stream
stop flowing, and the data has to be consumed via
readable.read()
. If the 'readable'
event handler is
removed, then the stream will start flowing again if there is a
'data'
event handler.
三种状态#
¥Three states
Readable
流的 "两种模式" 操作是对 Readable
流实现中发生的更复杂的内部状态管理的简化抽象。
¥The "two modes" of operation for a Readable
stream are a simplified
abstraction for the more complicated internal state management that is happening
within the Readable
stream implementation.
具体来说,在任何给定的时间点,每个 Readable
都处于三种可能的状态之一:
¥Specifically, at any given point in time, every Readable
is in one of three
possible states:
-
readable.readableFlowing === null
-
readable.readableFlowing === false
-
readable.readableFlowing === true
当 readable.readableFlowing
为 null
时,则不提供消费流数据的机制。因此,流不会生成数据。在此状态下,为 'data'
事件绑定监听器、调用 readable.pipe()
方法、或调用 readable.resume()
方法会将 readable.readableFlowing
切换到 true
,从而使 Readable
在生成数据时开始主动触发事件。
¥When readable.readableFlowing
is null
, no mechanism for consuming the
stream's data is provided. Therefore, the stream will not generate data.
While in this state, attaching a listener for the 'data'
event, calling the
readable.pipe()
method, or calling the readable.resume()
method will switch
readable.readableFlowing
to true
, causing the Readable
to begin actively
emitting events as data is generated.
调用 readable.pause()
、readable.unpipe()
或接收背压将导致 readable.readableFlowing
设置为 false
,暂时停止事件的流动但不会停止数据的生成。在此状态下,为 'data'
事件绑定监听器不会将 readable.readableFlowing
切换到 true
。
¥Calling readable.pause()
, readable.unpipe()
, or receiving backpressure
will cause the readable.readableFlowing
to be set as false
,
temporarily halting the flowing of events but not halting the generation of
data. While in this state, attaching a listener for the 'data'
event
will not switch readable.readableFlowing
to true
.
const { PassThrough, Writable } = require('node:stream');
const pass = new PassThrough();
const writable = new Writable();
pass.pipe(writable);
pass.unpipe(writable);
// readableFlowing is now false.
pass.on('data', (chunk) => { console.log(chunk.toString()); });
pass.write('ok'); // Will not emit 'data'.
pass.resume(); // Must be called to make stream emit 'data'.
虽然 readable.readableFlowing
是 false
,但数据可能会在流的内部缓冲区中累积。
¥While readable.readableFlowing
is false
, data may be accumulating
within the stream's internal buffer.
选择一种 API 风格#
¥Choose one API style
Readable
流的 API 跨越多个 Node.js 版本的演进,并提供了多种消费流数据的方法。一般来说,开发者应该选择一种消费数据的方法,而不应该使用多种方法来消费单个流中的数据。具体来说,使用 on('data')
、on('readable')
、pipe()
或异步迭代器的组合可能会导致不直观的行为。
¥The Readable
stream API evolved across multiple Node.js versions and provides
multiple methods of consuming stream data. In general, developers should choose
one of the methods of consuming data and should never use multiple methods
to consume data from a single stream. Specifically, using a combination
of on('data')
, on('readable')
, pipe()
, or async iterators could
lead to unintuitive behavior.
类:stream.Readable
#
¥Class: stream.Readable
事件:'close'
#
¥Event: 'close'
当流及其任何底层资源(例如文件描述符)已关闭时,则会触发 'close'
事件。该事件表明将不再触发更多事件,并且不会发生进一步的计算。
¥The 'close'
event is emitted when the stream and any of its underlying
resources (a file descriptor, for example) have been closed. The event indicates
that no more events will be emitted, and no further computation will occur.
如果 Readable
流是使用 emitClose
选项创建的,则始终会触发 'close'
事件。
¥A Readable
stream will always emit the 'close'
event if it is
created with the emitClose
option.
事件:'data'
#
¥Event: 'data'
-
chunk
<Buffer> | <string> | <any> 数据块。对于不在对象模式下操作的流,块将是字符串或Buffer
。对于处于对象模式的流,块可以是除null
之外的任何 JavaScript 值。¥
chunk
<Buffer> | <string> | <any> The chunk of data. For streams that are not operating in object mode, the chunk will be either a string orBuffer
. For streams that are in object mode, the chunk can be any JavaScript value other thannull
.
每当流将数据块的所有权移交给消费者时,则会触发 'data'
事件。每当通过调用 readable.pipe()
、readable.resume()
、或通过将监听器回调绑定到 'data'
事件而将流切换到流动模式时,就会发生这种情况。每当调用 readable.read()
方法并且可以返回数据块时,也会触发 'data'
事件。
¥The 'data'
event is emitted whenever the stream is relinquishing ownership of
a chunk of data to a consumer. This may occur whenever the stream is switched
in flowing mode by calling readable.pipe()
, readable.resume()
, or by
attaching a listener callback to the 'data'
event. The 'data'
event will
also be emitted whenever the readable.read()
method is called and a chunk of
data is available to be returned.
将 'data'
事件监听器绑定到尚未显式暂停的流,则会将流切换到流动模式。数据将在可用时立即传入。
¥Attaching a 'data'
event listener to a stream that has not been explicitly
paused will switch the stream into flowing mode. Data will then be passed as
soon as it is available.
如果使用 readable.setEncoding()
方法为流指定了默认编码,则监听器回调将把数据块作为字符串传递;否则数据将作为 Buffer
传递。
¥The listener callback will be passed the chunk of data as a string if a default
encoding has been specified for the stream using the
readable.setEncoding()
method; otherwise the data will be passed as a
Buffer
.
const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
console.log(`Received ${chunk.length} bytes of data.`);
});
事件:'end'
#
¥Event: 'end'
当流中没有更多数据可供消费时,则会触发 'end'
事件。
¥The 'end'
event is emitted when there is no more data to be consumed from
the stream.
除非数据完全消耗,否则不会触发 'end'
事件。这可以通过将流切换到流动模式来实现,或者通过重复调用 stream.read()
直到所有数据都被消费完。
¥The 'end'
event will not be emitted unless the data is completely
consumed. This can be accomplished by switching the stream into flowing mode,
or by calling stream.read()
repeatedly until all data has been
consumed.
const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
console.log(`Received ${chunk.length} bytes of data.`);
});
readable.on('end', () => {
console.log('There will be no more data.');
});
事件:'error'
#
¥Event: 'error'
'error'
事件可以随时由 Readable
的实现触发。通常,如果底层流由于底层内部故障而无法生成数据,或者当流实现尝试推送无效数据块时,可能会发生这种情况。
¥The 'error'
event may be emitted by a Readable
implementation at any time.
Typically, this may occur if the underlying stream is unable to generate data
due to an underlying internal failure, or when a stream implementation attempts
to push an invalid chunk of data.
监听器回调将传入单个 Error
对象。
¥The listener callback will be passed a single Error
object.
事件:'pause'
#
¥Event: 'pause'
当调用 stream.pause()
并且 readableFlowing
不是 false
时,则会触发 'pause'
事件。
¥The 'pause'
event is emitted when stream.pause()
is called
and readableFlowing
is not false
.
事件:'readable'
#
¥Event: 'readable'
当有可从流中读取的数据或已到达流的末尾时,则将触发 'readable'
事件。实际上,'readable'
事件表明流有新的信息。如果数据可用,则 stream.read()
将返回该数据。
¥The 'readable'
event is emitted when there is data available to be read from
the stream or when the end of the stream has been reached. Effectively, the
'readable'
event indicates that the stream has new information. If data is
available, stream.read()
will return that data.
const readable = getReadableStreamSomehow();
readable.on('readable', function() {
// There is some data to read now.
let data;
while ((data = this.read()) !== null) {
console.log(data);
}
});
如果已经到达流的末尾,则调用 stream.read()
将返回 null
并触发 'end'
事件。如果从未读取任何数据,则也是如此。例如,在以下示例中,foo.txt
是一个空文件:
¥If the end of the stream has been reached, calling
stream.read()
will return null
and trigger the 'end'
event. This is also true if there never was any data to be read. For instance,
in the following example, foo.txt
is an empty file:
const fs = require('node:fs');
const rr = fs.createReadStream('foo.txt');
rr.on('readable', () => {
console.log(`readable: ${rr.read()}`);
});
rr.on('end', () => {
console.log('end');
});
运行此脚本的输出是:
¥The output of running this script is:
$ node test.js
readable: null
end
在某些情况下,为 'readable'
事件绑定监听器会导致一些数据被读入内部缓冲区。
¥In some cases, attaching a listener for the 'readable'
event will cause some
amount of data to be read into an internal buffer.
一般来说,readable.pipe()
和 'data'
事件机制比 'readable'
事件更容易理解。但是,处理 'readable'
可能会导致吞吐量增加。
¥In general, the readable.pipe()
and 'data'
event mechanisms are easier to
understand than the 'readable'
event. However, handling 'readable'
might
result in increased throughput.
如果同时使用 'readable'
和 'data'
,则 'readable'
优先控制流,即只有在调用 stream.read()
时才会触发 'data'
。readableFlowing
属性将变为 false
。如果在删除 'readable'
时有 'data'
监听器,流将开始流动,即 'data'
事件将在不调用 .resume()
的情况下触发。
¥If both 'readable'
and 'data'
are used at the same time, 'readable'
takes precedence in controlling the flow, i.e. 'data'
will be emitted
only when stream.read()
is called. The
readableFlowing
property would become false
.
If there are 'data'
listeners when 'readable'
is removed, the stream
will start flowing, i.e. 'data'
events will be emitted without calling
.resume()
.
事件:'resume'
#
¥Event: 'resume'
当调用 stream.resume()
并且 readableFlowing
不是 true
时,则会触发 'resume'
事件。
¥The 'resume'
event is emitted when stream.resume()
is
called and readableFlowing
is not true
.
readable.destroy([error])
#
-
error
<Error> 将作为'error'
事件中的有效负载传递的错误¥
error
<Error> Error which will be passed as payload in'error'
event -
返回:<this>
¥Returns: <this>
销毁流可选地触发 'error'
事件,并且触发 'close'
事件(除非 emitClose
设置为 false
)。在此调用之后,可读流将释放任何内部资源,随后对 push()
的调用将被忽略。
¥Destroy the stream. Optionally emit an 'error'
event, and emit a 'close'
event (unless emitClose
is set to false
). After this call, the readable
stream will release any internal resources and subsequent calls to push()
will be ignored.
一旦 destroy()
被调用,任何进一步的调用都将是空操作,除了来自 _destroy()
的其他错误可能不会作为 'error'
触发。
¥Once destroy()
has been called any further calls will be a no-op and no
further errors except from _destroy()
may be emitted as 'error'
.
实现者不应覆盖此方法,而应实现 readable._destroy()
。
¥Implementors should not override this method, but instead implement
readable._destroy()
.
readable.destroyed
#
在调用 readable.destroy()
之后是 true
。
¥Is true
after readable.destroy()
has been called.
readable.isPaused()
#
readable.isPaused()
方法返回 Readable
的当前运行状态。这主要由作为 readable.pipe()
方法基础的机制使用。在大多数典型情况下,没有理由直接使用此方法。
¥The readable.isPaused()
method returns the current operating state of the
Readable
. This is used primarily by the mechanism that underlies the
readable.pipe()
method. In most typical cases, there will be no reason to
use this method directly.
const readable = new stream.Readable();
readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false
readable.pause()
#
readable.pause()
方法将导致处于流动模式的流停止触发 'data'
事件,切换出流动模式。任何可用的数据都将保留在内部缓冲区中。
¥The readable.pause()
method will cause a stream in flowing mode to stop
emitting 'data'
events, switching out of flowing mode. Any data that
becomes available will remain in the internal buffer.
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'
事件监听器,则 readable.pause()
方法不起作用。
¥The readable.pause()
method has no effect if there is a 'readable'
event listener.
readable.pipe(destination[, options])
#
-
destination
<stream.Writable> 写入数据的目标¥
destination
<stream.Writable> The destination for writing data -
options
<Object> 管道选项¥
options
<Object> Pipe options -
返回:<stream.Writable> 目标,如果它是
Duplex
或Transform
流,则允许管道链¥Returns: <stream.Writable> The destination, allowing for a chain of pipes if it is a
Duplex
or aTransform
stream
readable.pipe()
方法将 Writable
流绑定到 readable
,使其自动切换到流动模式并将其所有数据推送到绑定的 Writable
。数据流将被自动管理,以便目标 Writable
流不会被更快的 Readable
流漫过。
¥The readable.pipe()
method attaches a Writable
stream to the readable
,
causing it to switch automatically into flowing mode and push all of its data
to the attached Writable
. The flow of data will be automatically managed
so that the destination Writable
stream is not overwhelmed by a faster
Readable
stream.
以下示例将 readable
中的所有数据通过管道传输到名为 file.txt
的文件中:
¥The following example pipes all of the data from the readable
into a file
named file.txt
:
const fs = require('node:fs');
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt'.
readable.pipe(writable);
可以将多个 Writable
流绑定到单个 Readable
流。
¥It is possible to attach multiple Writable
streams to a single Readable
stream.
readable.pipe()
方法返回对目标流的引用,从而可以设置管道流链:
¥The readable.pipe()
method returns a reference to the destination stream
making it possible to set up chains of piped streams:
const fs = require('node:fs');
const zlib = require('node:zlib');
const r = fs.createReadStream('file.txt');
const z = zlib.createGzip();
const w = fs.createWriteStream('file.txt.gz');
r.pipe(z).pipe(w);
默认情况下,当源 Readable
流触发 'end'
时,则在目标 Writable
流上调用 stream.end()
,因此目标不再可写。要禁用此默认行为,可以将 end
选项作为 false
传入,从而使目标流保持打开状态:
¥By default, stream.end()
is called on the destination Writable
stream when the source Readable
stream emits 'end'
, so that the
destination is no longer writable. To disable this default behavior, the end
option can be passed as false
, causing the destination stream to remain open:
reader.pipe(writer, { end: false });
reader.on('end', () => {
writer.end('Goodbye\n');
});
一个重要的警告是,如果 Readable
流在处理过程中触发错误,则 Writable
目标不会自动关闭。如果发生错误,则需要手动关闭每个流以防止内存泄漏。
¥One important caveat is that if the Readable
stream emits an error during
processing, the Writable
destination is not closed automatically. If an
error occurs, it will be necessary to manually close each stream in order
to prevent memory leaks.
process.stderr
和 process.stdout
Writable
流在 Node.js 进程退出之前永远不会关闭,无论指定的选项如何。
¥The process.stderr
and process.stdout
Writable
streams are never
closed until the Node.js process exits, regardless of the specified options.
readable.read([size])
#
-
size
<number> 用于指定要读取的数据量的可选参数。¥
size
<number> Optional argument to specify how much data to read.
readable.read()
方法从内部缓冲区中读取数据并返回。如果没有数据可以读取,则返回 null
。默认情况下,除非使用 readable.setEncoding()
方法指定了编码或流在对象模式下运行,否则数据将作为 Buffer
对象返回。
¥The readable.read()
method reads data out of the internal buffer and
returns it. If no data is available to be read, null
is returned. By default,
the data is returned as a Buffer
object unless an encoding has been
specified using the readable.setEncoding()
method or the stream is operating
in object mode.
可选的 size
参数指定要读取的特定字节数。如果无法读取 size
个字节,则将返回 null
,除非流已结束,在这种情况下,将返回内部缓冲区中剩余的所有数据。
¥The optional size
argument specifies a specific number of bytes to read. If
size
bytes are not available to be read, null
will be returned unless
the stream has ended, in which case all of the data remaining in the internal
buffer will be returned.
如果未指定 size
参数,则将返回内部缓冲区中包含的所有数据。
¥If the size
argument is not specified, all of the data contained in the
internal buffer will be returned.
size
参数必须小于或等于 1 GiB。
¥The size
argument must be less than or equal to 1 GiB.
readable.read()
方法应该只在暂停模式下操作的 Readable
流上调用。在流动模式下,会自动调用 readable.read()
,直到内部缓冲区完全排空。
¥The readable.read()
method should only be called on Readable
streams
operating in paused mode. In flowing mode, readable.read()
is called
automatically until the internal buffer is fully drained.
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'
事件。
¥Each call to readable.read()
returns a chunk of data, or null
. The chunks
are not concatenated. A while
loop is necessary to consume all data
currently in the buffer. When reading a large file .read()
may return null
,
having consumed all buffered content so far, but there is still more data to
come not yet buffered. In this case a new 'readable'
event will be emitted
when there is more data in the buffer. Finally the 'end'
event will be
emitted when there is no more data to come.
因此,要从 readable
读取文件的全部内容,必须跨越多个 'readable'
事件来收集块:
¥Therefore to read a file's whole contents from a readable
, it is necessary
to collect chunks across multiple 'readable'
events:
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
参数的值如何。
¥A Readable
stream in object mode will always return a single item from
a call to readable.read(size)
, regardless of the value of the
size
argument.
如果 readable.read()
方法返回数据块,则还将触发 'data'
事件。
¥If the readable.read()
method returns a chunk of data, a 'data'
event will
also be emitted.
在触发 'end'
事件后调用 stream.read([size])
将返回 null
。不会引发运行时错误。
¥Calling stream.read([size])
after the 'end'
event has
been emitted will return null
. No runtime error will be raised.
readable.readable
#
如果调用 readable.read()
是安全的,则为 true
,这意味着流尚未被销毁或触发 'error'
或 'end'
。
¥Is true
if it is safe to call readable.read()
, which means
the stream has not been destroyed or emitted 'error'
or 'end'
.
readable.readableAborted
#
¥Stability: 1 - Experimental
返回在触发 'end'
之前流是被破销毁或出错。
¥Returns whether the stream was destroyed or errored before emitting 'end'
.
readable.readableDidRead
#
¥Stability: 1 - Experimental
返回 'data'
是否已经触发。
¥Returns whether 'data'
has been emitted.
readable.readableEncoding
#
给定 Readable
流的属性 encoding
的获取器。可以使用 readable.setEncoding()
方法设置 encoding
属性。
¥Getter for the property encoding
of a given Readable
stream. The encoding
property can be set using the readable.setEncoding()
method.
readable.readableEnded
#
当触发 'end'
事件时变为 true
。
¥Becomes true
when 'end'
event is emitted.
readable.readableFlowing
#
如 三种状态 部分所述,此属性反映 Readable
流的当前状态。
¥This property reflects the current state of a Readable
stream as described
in the Three states section.
readable.readableHighWaterMark
#
返回创建此 Readable
时传递的 highWaterMark
的值。
¥Returns the value of highWaterMark
passed when creating this Readable
.
readable.readableLength
#
此属性包含队列中准备读取的字节数(或对象数)。该值提供有关 highWaterMark
状态的内省数据。
¥This property contains the number of bytes (or objects) in the queue
ready to be read. The value provides introspection data regarding
the status of the highWaterMark
.
readable.readableObjectMode
#
给定 Readable
流的属性 objectMode
的获取器。
¥Getter for the property objectMode
of a given Readable
stream.
readable.resume()
#
readable.resume()
方法导致显式暂停的 Readable
流恢复触发 'data'
事件,将流切换到流动模式。
¥The readable.resume()
method causes an explicitly paused Readable
stream to
resume emitting 'data'
events, switching the stream into flowing mode.
readable.resume()
方法可用于完全使用流中的数据,而无需实际处理任何数据:
¥The readable.resume()
method can be used to fully consume the data from a
stream without actually processing any of that data:
getReadableStreamSomehow()
.resume()
.on('end', () => {
console.log('Reached the end, but did not read anything.');
});
如果有 'readable'
事件监听器,则 readable.resume()
方法不起作用。
¥The readable.resume()
method has no effect if there is a 'readable'
event listener.
readable.setEncoding(encoding)
#
readable.setEncoding()
方法设置从 Readable
流中读取的数据的字符编码。
¥The readable.setEncoding()
method sets the character encoding for
data read from the Readable
stream.
默认情况下,没有分配编码,流数据将作为 Buffer
对象返回。设置编码会导致流数据作为指定编码的字符串而不是 Buffer
对象返回。例如,调用 readable.setEncoding('utf8')
将导致输出数据被解释为 UTF-8 数据,并作为字符串传递。调用 readable.setEncoding('hex')
将导致数据以十六进制字符串格式编码。
¥By default, no encoding is assigned and stream data will be returned as
Buffer
objects. Setting an encoding causes the stream data
to be returned as strings of the specified encoding rather than as Buffer
objects. For instance, calling readable.setEncoding('utf8')
will cause the
output data to be interpreted as UTF-8 data, and passed as strings. Calling
readable.setEncoding('hex')
will cause the data to be encoded in hexadecimal
string format.
Readable
流将正确处理通过流传送的多字节字符,否则如果简单地将其作为 Buffer
对象从流中提取,这些字符将无法正确解码。
¥The Readable
stream will properly handle multi-byte characters delivered
through the stream that would otherwise become improperly decoded if simply
pulled from the stream as Buffer
objects.
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);
});
readable.unpipe([destination])
#
-
destination
<stream.Writable> 可选的要取消管道的特定流¥
destination
<stream.Writable> Optional specific stream to unpipe -
返回:<this>
¥Returns: <this>
readable.unpipe()
方法分离先前使用 stream.pipe()
方法附加的 Writable
流。
¥The readable.unpipe()
method detaches a Writable
stream previously attached
using the stream.pipe()
method.
如果未指定 destination
,则分离所有管道。
¥If the destination
is not specified, then all pipes are detached.
如果指定了 destination
,但没有为其设置管道,则该方法不执行任何操作。
¥If the destination
is specified, but no pipe is set up for it, then
the method does nothing.
const fs = require('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);
readable.unshift(chunk[, encoding])
#
-
chunk
<Buffer> | <Uint8Array> | <string> | <null> | <any> 要取消转移到读取队列的数据块。对于不以对象模式运行的流,chunk
必须是字符串、Buffer
、Uint8Array
或null
。对于对象模式流,chunk
可以是任何 JavaScript 值。¥
chunk
<Buffer> | <Uint8Array> | <string> | <null> | <any> Chunk of data to unshift onto the read queue. For streams not operating in object mode,chunk
must be a string,Buffer
,Uint8Array
, ornull
. For object mode streams,chunk
may be any JavaScript value. -
encoding
<string> 字符串块的编码。必须是有效的Buffer
编码,例如'utf8'
或'ascii'
。¥
encoding
<string> Encoding of string chunks. Must be a validBuffer
encoding, such as'utf8'
or'ascii'
.
将 chunk
作为 null
传递表示流结束 (EOF),其行为与 readable.push(null)
相同,之后无法写入更多数据。EOF 信号放在缓冲区的末尾,任何缓冲的数据仍将被刷新。
¥Passing chunk
as null
signals the end of the stream (EOF) and behaves the
same as readable.push(null)
, after which no more data can be written. The EOF
signal is put at the end of the buffer and any buffered data will still be
flushed.
readable.unshift()
方法将一大块数据推回内部缓冲区。这在某些情况下很有用,在这种情况下,流正在被需要 "un-consume" 乐观地从源中提取的一些数据的代码使用,以便可以将数据传递给其他方。
¥The readable.unshift()
method pushes a chunk of data back into the internal
buffer. This is useful in certain situations where a stream is being consumed by
code that needs to "un-consume" some amount of data that it has optimistically
pulled out of the source, so that the data can be passed on to some other party.
在触发 'end'
事件后不能调用 stream.unshift(chunk)
方法,否则将抛出运行时错误。
¥The stream.unshift(chunk)
method cannot be called after the 'end'
event
has been emitted or a runtime error will be thrown.
经常使用 stream.unshift()
的开发者应该考虑改用 Transform
流。有关详细信息,请参阅 流实现者的 API 部分。
¥Developers using stream.unshift()
often should consider switching to
use of a Transform
stream instead. See the API for stream implementers
section for more information.
// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
const { StringDecoder } = require('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.push(chunk)
不同,stream.unshift(chunk)
不会通过重置流的内部读取状态来结束读取过程。如果在读取期间调用 readable.unshift()
(即从自定义流上的 stream._read()
实现中调用),这可能会导致意外结果。在调用 readable.unshift()
后立即调用 stream.push('')
将适当地重置读取状态,但是最好避免在执行读取过程中调用 readable.unshift()
。
¥Unlike stream.push(chunk)
, stream.unshift(chunk)
will not
end the reading process by resetting the internal reading state of the stream.
This can cause unexpected results if readable.unshift()
is called during a
read (i.e. from within a stream._read()
implementation on a
custom stream). Following the call to readable.unshift()
with an immediate
stream.push('')
will reset the reading state appropriately,
however it is best to simply avoid calling readable.unshift()
while in the
process of performing a read.
readable.wrap(stream)
#
在 Node.js 0.10 之前,流没有实现当前定义的整个 node:stream
模块 API。(有关详细信息,请参阅 兼容性。)
¥Prior to Node.js 0.10, streams did not implement the entire node:stream
module API as it is currently defined. (See Compatibility for more
information.)
当使用触发 'data'
事件并具有仅供参考的 stream.pause()
方法的旧 Node.js 库时,readable.wrap()
方法可用于创建使用旧流作为其数据源的 Readable
流。
¥When using an older Node.js library that emits 'data'
events and has a
stream.pause()
method that is advisory only, the
readable.wrap()
method can be used to create a Readable
stream that uses
the old stream as its data source.
很少需要使用 readable.wrap()
,但提供该方法是为了方便与旧的 Node.js 应用和库进行交互。
¥It will rarely be necessary to use readable.wrap()
but the method has been
provided as a convenience for interacting with older Node.js applications and
libraries.
const { OldReader } = require('./old-api-module.js');
const { Readable } = require('node:stream');
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);
myReader.on('readable', () => {
myReader.read(); // etc.
});
readable[Symbol.asyncIterator]()
#
-
返回:<AsyncIterator> 完全消耗流。
¥Returns: <AsyncIterator> to fully consume the stream.
const fs = require('node:fs');
async function print(readable) {
readable.setEncoding('utf8');
let data = '';
for await (const chunk of readable) {
data += chunk;
}
console.log(data);
}
print(fs.createReadStream('file')).catch(console.error);
如果循环以 break
、return
或 throw
终止,则流将被销毁。换句话说,迭代流将完全消耗流。流将以等于 highWaterMark
选项大小的块读取。在上面的代码示例中,如果文件的数据少于 64 KiB,则数据将位于单个块中,因为没有向 fs.createReadStream()
提供 highWaterMark
选项。
¥If the loop terminates with a break
, return
, or a throw
, the stream will
be destroyed. In other terms, iterating over a stream will consume the stream
fully. The stream will be read in chunks of size equal to the highWaterMark
option. In the code example above, data will be in a single chunk if the file
has less then 64 KiB of data because no highWaterMark
option is provided to
fs.createReadStream()
.
readable.iterator([options])
#
¥Stability: 1 - Experimental
-
options
<Object>-
destroyOnReturn
<boolean> 当设置为false
时,在异步迭代器上调用return
或使用break
、return
或throw
退出for await...of
迭代不会销毁流。默认值:true
。¥
destroyOnReturn
<boolean> When set tofalse
, callingreturn
on the async iterator, or exiting afor await...of
iteration using abreak
,return
, orthrow
will not destroy the stream. Default:true
. -
destroyOnError
<boolean> 当设置为false
时,如果流在迭代时触发错误,迭代器将不会销毁流。默认值:true
。¥
destroyOnError
<boolean> When set tofalse
, if the stream emits an error while it's being iterated, the iterator will not destroy the stream. Default:true
.
-
-
返回:<AsyncIterator> 来消费流。
¥Returns: <AsyncIterator> to consume the stream.
如果 return
、break
或 throw
退出 for await...of
循环,或者如果迭代器在迭代期间流触发错误时应销毁流,则此方法创建的迭代器为用户提供了取消流销毁的选项。
¥The iterator created by this method gives users the option to cancel the
destruction of the stream if the for await...of
loop is exited by return
,
break
, or throw
, or if the iterator should destroy the stream if the stream
emitted an error during iteration.
const { Readable } = require('node:stream');
async function printIterator(readable) {
for await (const chunk of readable.iterator({ destroyOnReturn: false })) {
console.log(chunk); // 1
break;
}
console.log(readable.destroyed); // false
for await (const chunk of readable.iterator({ destroyOnReturn: false })) {
console.log(chunk); // Will print 2 and then 3
}
console.log(readable.destroyed); // True, stream was totally consumed
}
async function printSymbolAsyncIterator(readable) {
for await (const chunk of readable) {
console.log(chunk); // 1
break;
}
console.log(readable.destroyed); // true
}
async function showBoth() {
await printIterator(Readable.from([1, 2, 3]));
await printSymbolAsyncIterator(Readable.from([1, 2, 3]));
}
showBoth();
readable.map(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 映射流中每个块的函数。¥
fn
<Function> | <AsyncFunction> a function to map over every chunk in the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 是用函数
fn
映射的流。¥Returns: <Readable> a stream mapped with the function
fn
.
此方法允许在流上进行映射。将为流中的每个块调用 fn
函数。如果 fn
函数返回一个 promise - 该 promise 在传递到结果流之前将被 await
。
¥This method allows mapping over the stream. The fn
function will be called
for every chunk in the stream. If the fn
function returns a promise - that
promise will be await
ed before being passed to the result stream.
import { Readable } from 'node:stream';
import { Resolver } from 'node:dns/promises';
// With a synchronous mapper.
for await (const chunk of Readable.from([1, 2, 3, 4]).map((x) => x * 2)) {
console.log(chunk); // 2, 4, 6, 8
}
// With an asynchronous mapper, making at most 2 queries at a time.
const resolver = new Resolver();
const dnsResults = Readable.from([
'nodejs.org',
'openjsf.org',
'www.linuxfoundation.org',
]).map((domain) => resolver.resolve4(domain), { concurrency: 2 });
for await (const result of dnsResults) {
console.log(result); // Logs the DNS result of resolver.resolve4.
}
readable.filter(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 从流中过滤块的函数。¥
fn
<Function> | <AsyncFunction> a function to filter chunks from the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 使用谓词
fn
过滤的流。¥Returns: <Readable> a stream filtered with the predicate
fn
.
此方法允许过滤流。对于流中的每个块,将调用 fn
函数,如果它返回真值,则该块将传递到结果流。如果 fn
函数返回一个 promise - 这个 promise 将会被 await
。
¥This method allows filtering the stream. For each chunk in the stream the fn
function will be called and if it returns a truthy value, the chunk will be
passed to the result stream. If the fn
function returns a promise - that
promise will be await
ed.
import { Readable } from 'node:stream';
import { Resolver } from 'node:dns/promises';
// With a synchronous predicate.
for await (const chunk of Readable.from([1, 2, 3, 4]).filter((x) => x > 2)) {
console.log(chunk); // 3, 4
}
// With an asynchronous predicate, making at most 2 queries at a time.
const resolver = new Resolver();
const dnsResults = Readable.from([
'nodejs.org',
'openjsf.org',
'www.linuxfoundation.org',
]).filter(async (domain) => {
const { address } = await resolver.resolve4(domain, { ttl: true });
return address.ttl > 60;
}, { concurrency: 2 });
for await (const result of dnsResults) {
// Logs domains with more than 60 seconds on the resolved dns record.
console.log(result);
}
readable.forEach(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 调用流的每个块的函数。¥
fn
<Function> | <AsyncFunction> a function to call on each chunk of the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Promise> 流完成时的 promise。
¥Returns: <Promise> a promise for when the stream has finished.
此方法允许迭代流。对于流中的每个块,将调用 fn
函数。如果 fn
函数返回一个 promise - 这个 promise 将会被 await
。
¥This method allows iterating a stream. For each chunk in the stream the
fn
function will be called. If the fn
function returns a promise - that
promise will be await
ed.
此方法与 for await...of
循环的不同之处在于它可以选择并发处理块。此外,forEach
迭代只能通过传递 signal
选项并中止相关的 AbortController
来停止,而 for await...of
可以使用 break
或 return
停止。在任何一种情况下,流都将被销毁。
¥This method is different from for await...of
loops in that it can optionally
process chunks concurrently. In addition, a forEach
iteration can only be
stopped by having passed a signal
option and aborting the related
AbortController
while for await...of
can be stopped with break
or
return
. In either case the stream will be destroyed.
该方法与监听 'data'
事件的不同之处在于,它使用底层机制中的 readable
事件,可以限制并发 fn
调用的数量。
¥This method is different from listening to the 'data'
event in that it
uses the readable
event in the underlying machinary and can limit the
number of concurrent fn
calls.
import { Readable } from 'node:stream';
import { Resolver } from 'node:dns/promises';
// With a synchronous predicate.
for await (const chunk of Readable.from([1, 2, 3, 4]).filter((x) => x > 2)) {
console.log(chunk); // 3, 4
}
// With an asynchronous predicate, making at most 2 queries at a time.
const resolver = new Resolver();
const dnsResults = await Readable.from([
'nodejs.org',
'openjsf.org',
'www.linuxfoundation.org',
]).map(async (domain) => {
const { address } = await resolver.resolve4(domain, { ttl: true });
return address;
}, { concurrency: 2 });
await dnsResults.forEach((result) => {
// Logs result, similar to `for await (const result of dnsResults)`
console.log(result);
});
console.log('done'); // Stream has finished
readable.toArray([options])
#
¥Stability: 1 - Experimental
-
options
<Object>-
signal
<AbortSignal> 如果信号中止,则允许取消 toArray 操作。¥
signal
<AbortSignal> allows cancelling the toArray operation if the signal is aborted.
-
-
返回:<Promise> 一个包含包含流内容的数组的 Promise。
¥Returns: <Promise> a promise containing an array with the contents of the stream.
此方法允许轻松获取流的内容。
¥This method allows easily obtaining the contents of a stream.
由于此方法将整个流读入内存,因此抵消了流的优势。它旨在实现互操作性和便利性,而不是作为消费流的主要方式。
¥As this method reads the entire stream into memory, it negates the benefits of streams. It's intended for interoperability and convenience, not as the primary way to consume streams.
import { Readable } from 'node:stream';
import { Resolver } from 'node:dns/promises';
await Readable.from([1, 2, 3, 4]).toArray(); // [1, 2, 3, 4]
// Make dns queries concurrently using .map and collect
// the results into an array using toArray
const dnsResults = await Readable.from([
'nodejs.org',
'openjsf.org',
'www.linuxfoundation.org',
]).map(async (domain) => {
const { address } = await resolver.resolve4(domain, { ttl: true });
return address;
}, { concurrency: 2 }).toArray();
readable.some(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 调用流的每个块的函数。¥
fn
<Function> | <AsyncFunction> a function to call on each chunk of the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:如果
fn
至少为其中一个块返回真值,则 <Promise> 是评估true
的 promise。¥Returns: <Promise> a promise evaluating to
true
iffn
returned a truthy value for at least one of the chunks.
此方法类似于 Array.prototype.some
,并在流中的每个块上调用 fn
,直到等待的返回值为 true
(或任何真值)。一旦对块等待返回值的 fn
调用为真,流就会被销毁,并用 true
实现 promise。如果对块的 fn
调用都没有返回真值,则 promise 由 false
实现。
¥This method is similar to Array.prototype.some
and calls fn
on each chunk
in the stream until the awaited return value is true
(or any truthy value).
Once an fn
call on a chunk awaited return value is truthy, the stream is
destroyed and the promise is fulfilled with true
. If none of the fn
calls on the chunks return a truthy value, the promise is fulfilled with
false
.
import { Readable } from 'node:stream';
import { stat } from 'node:fs/promises';
// With a synchronous predicate.
await Readable.from([1, 2, 3, 4]).some((x) => x > 2); // true
await Readable.from([1, 2, 3, 4]).some((x) => x < 0); // false
// With an asynchronous predicate, making at most 2 file checks at a time.
const anyBigFile = await Readable.from([
'file1',
'file2',
'file3',
]).some(async (fileName) => {
const stats = await stat(fileName);
return stat.size > 1024 * 1024;
}, { concurrency: 2 });
console.log(anyBigFile); // `true` if any file in the list is bigger than 1MB
console.log('done'); // Stream has finished
readable.find(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 调用流的每个块的函数。¥
fn
<Function> | <AsyncFunction> a function to call on each chunk of the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Promise> 是评估第一个块的 promise,其中
fn
使用真值进行评估,如果未找到元素,则评估undefined
。¥Returns: <Promise> a promise evaluating to the first chunk for which
fn
evaluated with a truthy value, orundefined
if no element was found.
此方法类似于 Array.prototype.find
,并在流中的每个块上调用 fn
以查找具有 fn
真值的块。一旦 fn
调用的等待返回值是真实的,流就会被销毁,并且 promise 会用 fn
返回真实值的值来实现。如果对块的所有 fn
调用都返回一个假值,则 promise 通过 undefined
实现。
¥This method is similar to Array.prototype.find
and calls fn
on each chunk
in the stream to find a chunk with a truthy value for fn
. Once an fn
call's
awaited return value is truthy, the stream is destroyed and the promise is
fulfilled with value for which fn
returned a truthy value. If all of the
fn
calls on the chunks return a falsy value, the promise is fulfilled with
undefined
.
import { Readable } from 'node:stream';
import { stat } from 'node:fs/promises';
// With a synchronous predicate.
await Readable.from([1, 2, 3, 4]).find((x) => x > 2); // 3
await Readable.from([1, 2, 3, 4]).find((x) => x > 0); // 1
await Readable.from([1, 2, 3, 4]).find((x) => x > 10); // undefined
// With an asynchronous predicate, making at most 2 file checks at a time.
const foundBigFile = await Readable.from([
'file1',
'file2',
'file3',
]).find(async (fileName) => {
const stats = await stat(fileName);
return stat.size > 1024 * 1024;
}, { concurrency: 2 });
console.log(foundBigFile); // File name of large file, if any file in the list is bigger than 1MB
console.log('done'); // Stream has finished
readable.every(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 调用流的每个块的函数。¥
fn
<Function> | <AsyncFunction> a function to call on each chunk of the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:如果
fn
返回所有块的真值,则 <Promise> 是评估true
的 promise。¥Returns: <Promise> a promise evaluating to
true
iffn
returned a truthy value for all of the chunks.
此方法类似于 Array.prototype.every
,并在流中的每个块上调用 fn
,以检查所有等待的返回值是否为 fn
的真值。一旦对块等待返回值的 fn
调用是假的,流就会被销毁,并且 promise 会用 false
实现。如果对块的所有 fn
调用都返回真值,则 promise 通过 true
实现。
¥This method is similar to Array.prototype.every
and calls fn
on each chunk
in the stream to check if all awaited return values are truthy value for fn
.
Once an fn
call on a chunk awaited return value is falsy, the stream is
destroyed and the promise is fulfilled with false
. If all of the fn
calls
on the chunks return a truthy value, the promise is fulfilled with true
.
import { Readable } from 'node:stream';
import { stat } from 'node:fs/promises';
// With a synchronous predicate.
await Readable.from([1, 2, 3, 4]).every((x) => x > 2); // false
await Readable.from([1, 2, 3, 4]).every((x) => x > 0); // true
// With an asynchronous predicate, making at most 2 file checks at a time.
const allBigFiles = await Readable.from([
'file1',
'file2',
'file3',
]).every(async (fileName) => {
const stats = await stat(fileName);
return stat.size > 1024 * 1024;
}, { concurrency: 2 });
// `true` if all files in the list are bigger than 1MiB
console.log(allBigFiles);
console.log('done'); // Stream has finished
readable.flatMap(fn[, options])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncGeneratorFunction> | <AsyncFunction> 映射流中每个块的函数。¥
fn
<Function> | <AsyncGeneratorFunction> | <AsyncFunction> a function to map over every chunk in the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 是使用函数
fn
进行扁平映射的流。¥Returns: <Readable> a stream flat-mapped with the function
fn
.
此方法通过将给定回调应用于流的每个块然后展平结果来返回新流。
¥This method returns a new stream by applying the given callback to each chunk of the stream and then flattening the result.
可以从 fn
返回流或另一个可迭代或异步可迭代,结果流将合并(展平)到返回的流中。
¥It is possible to return a stream or another iterable or async iterable from
fn
and the result streams will be merged (flattened) into the returned
stream.
import { Readable } from 'node:stream';
import { createReadStream } from 'node:fs';
// With a synchronous mapper.
for await (const chunk of Readable.from([1, 2, 3, 4]).flatMap((x) => [x, x])) {
console.log(chunk); // 1, 1, 2, 2, 3, 3, 4, 4
}
// With an asynchronous mapper, combine the contents of 4 files
const concatResult = Readable.from([
'./1.mjs',
'./2.mjs',
'./3.mjs',
'./4.mjs',
]).flatMap((fileName) => createReadStream(fileName));
for await (const result of concatResult) {
// This will contain the contents (all chunks) of all 4 files
console.log(result);
}
readable.drop(limit[, options])
#
¥Stability: 1 - Experimental
-
limit
<number> 从可读中删除的块数。¥
limit
<number> the number of chunks to drop from the readable. -
options
<Object>-
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 是一个流,其中有
limit
个块被丢弃。¥Returns: <Readable> a stream with
limit
chunks dropped.
此方法返回一个新流,其中删除了前 limit
个块。
¥This method returns a new stream with the first limit
chunks dropped.
import { Readable } from 'node:stream';
await Readable.from([1, 2, 3, 4]).drop(2).toArray(); // [3, 4]
readable.take(limit[, options])
#
¥Stability: 1 - Experimental
-
limit
<number> 从可读块中获取的块数。¥
limit
<number> the number of chunks to take from the readable. -
options
<Object>-
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 是一个带有
limit
块的流。¥Returns: <Readable> a stream with
limit
chunks taken.
此方法返回一个包含前 limit
个块的新流。
¥This method returns a new stream with the first limit
chunks.
import { Readable } from 'node:stream';
await Readable.from([1, 2, 3, 4]).take(2).toArray(); // [1, 2]
readable.asIndexedPairs([options])
#
¥Stability: 1 - Experimental
-
options
<Object>-
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 索引对流。
¥Returns: <Readable> a stream of indexed pairs.
此方法返回一个新流,其中包含底层流的块,并与 [index, chunk]
形式的计数器配对。第一个索引值为 0,每生成一个块它就会增加 1。
¥This method returns a new stream with chunks of the underlying stream paired
with a counter in the form [index, chunk]
. The first index value is 0 and it
increases by 1 for each chunk produced.
import { Readable } from 'node:stream';
const pairs = await Readable.from(['a', 'b', 'c']).asIndexedPairs().toArray();
console.log(pairs); // [[0, 'a'], [1, 'b'], [2, 'c']]
readable.reduce(fn[, initial[, options]])
#
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 一个 reducer 函数来调用流中的每个块。¥
fn
<Function> | <AsyncFunction> a reducer function to call over every chunk in the stream.-
previous
<any> 从最后一次调用fn
获得的值或initial
值(如果指定)或流的第一个块。¥
previous
<any> the value obtained from the last call tofn
or theinitial
value if specified or the first chunk of the stream otherwise. -
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
initial
<any> 用于减少的初始值。¥
initial
<any> the initial value to use in the reduction. -
options
<Object>-
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Promise> 对最终减少值的 promise。
¥Returns: <Promise> a promise for the final value of the reduction.
此方法按顺序在流的每个块上调用 fn
,将前一个元素的计算结果传递给它。它返回对减少的最终值的 promise。
¥This method calls fn
on each chunk of the stream in order, passing it the
result from the calculation on the previous element. It returns a promise for
the final value of the reduction.
reducer 函数逐个元素地迭代流,这意味着没有 concurrency
参数或并行性。要同时执行 reduce
,可以将其链接到 readable.map
方法。
¥The reducer function iterates the stream element-by-element which means that
there is no concurrency
parameter or parallelism. To perform a reduce
concurrently, it can be chained to the readable.map
method.
如果没有提供 initial
值,则流的第一个块将用作初始值。如果流为空,则使用 TypeError
和 ERR_INVALID_ARGS
代码属性拒绝 promise。
¥If no initial
value is supplied the first chunk of the stream is used as the
initial value. If the stream is empty, the promise is rejected with a
TypeError
with the ERR_INVALID_ARGS
code property.
import { Readable } from 'node:stream';
const ten = await Readable.from([1, 2, 3, 4]).reduce((previous, data) => {
return previous + data;
});
console.log(ten); // 10
双工和转换流#
¥Duplex and transform streams
类:stream.Duplex
#
¥Class: stream.Duplex
双工流是同时实现 Readable
和 Writable
接口的流。
¥Duplex streams are streams that implement both the Readable
and
Writable
interfaces.
Duplex
流的示例包括:
¥Examples of Duplex
streams include:
duplex.allowHalfOpen
#
如果为 false
,则流将在可读端结束时自动结束可写端。最初由 allowHalfOpen
构造函数选项设置,默认为 true
。
¥If false
then the stream will automatically end the writable side when the
readable side ends. Set initially by the allowHalfOpen
constructor option,
which defaults to true
.
这可以手动更改以更改现有 Duplex
流实例的半打开行为,但必须在触发 'end'
事件之前更改。
¥This can be changed manually to change the half-open behavior of an existing
Duplex
stream instance, but must be changed before the 'end'
event is
emitted.
类:stream.Transform
#
¥Class: stream.Transform
转换流是 Duplex
流,其中输出以某种方式与输入相关。与所有 Duplex
流一样,Transform
流同时实现 Readable
和 Writable
接口。
¥Transform streams are Duplex
streams where the output is in some way
related to the input. Like all Duplex
streams, Transform
streams
implement both the Readable
and Writable
interfaces.
Transform
流的示例包括:
¥Examples of Transform
streams include:
transform.destroy([error])
#
销毁流,并可选择触发 'error'
事件。在此调用之后,转换流将释放所有内部资源。实现者不应覆盖此方法,而应实现 readable._destroy()
。Transform
的 _destroy()
的默认实现也会触发 'close'
,除非 emitClose
设置为 false。
¥Destroy the stream, and optionally emit an 'error'
event. After this call, the
transform stream would release any internal resources.
Implementors should not override this method, but instead implement
readable._destroy()
.
The default implementation of _destroy()
for Transform
also emit 'close'
unless emitClose
is set in false.
一旦调用了 destroy()
,任何进一步的调用都将是空操作,并且除了 _destroy()
之外的任何其他错误都不会作为 'error'
触发。
¥Once destroy()
has been called, any further calls will be a no-op and no
further errors except from _destroy()
may be emitted as 'error'
.
stream.finished(stream[, options], callback)
#
-
stream
<Stream> 可读和/或可写流。¥
stream
<Stream> A readable and/or writable stream. -
options
<Object>-
error
<boolean> 如果设置为false
,则对emit('error', err)
的调用不会被视为已完成。默认值:true
。¥
error
<boolean> If set tofalse
, then a call toemit('error', err)
is not treated as finished. Default:true
. -
readable
<boolean> 当设置为false
时,即使流可能仍然可读,也会在流结束时调用回调。默认值:true
。¥
readable
<boolean> When set tofalse
, the callback will be called when the stream ends even though the stream might still be readable. Default:true
. -
writable
<boolean> 当设置为false
时,即使流可能仍可写,也会在流结束时调用回调。默认值:true
。¥
writable
<boolean> When set tofalse
, the callback will be called when the stream ends even though the stream might still be writable. Default:true
. -
signal
<AbortSignal> 允许中止等待流完成。如果信号被中止,底层流将不会被中止。将使用AbortError
调用回调。此函数添加的所有已注册监听器也将被删除。¥
signal
<AbortSignal> allows aborting the wait for the stream finish. The underlying stream will not be aborted if the signal is aborted. The callback will get called with anAbortError
. All registered listeners added by this function will also be removed.
-
-
callback
<Function> 采用可选的错误参数的回调函数。¥
callback
<Function> A callback function that takes an optional error argument. -
返回:<Function> 清除所有已注册监听器的函数。
¥Returns: <Function> A cleanup function which removes all registered listeners.
当流不再可读、不可写或遇到错误或过早关闭事件时获得通知的函数。
¥A function to get notified when a stream is no longer readable, writable or has experienced an error or a premature close event.
const { finished } = require('node:stream');
const fs = require('node:fs');
const rs = fs.createReadStream('archive.tar');
finished(rs, (err) => {
if (err) {
console.error('Stream failed.', err);
} else {
console.log('Stream is done reading.');
}
});
rs.resume(); // Drain the stream.
在流被过早销毁(如中止的 HTTP 请求)并且不会触发 'end'
或 'finish'
的错误处理场景中特别有用。
¥Especially useful in error handling scenarios where a stream is destroyed
prematurely (like an aborted HTTP request), and will not emit 'end'
or 'finish'
.
finished
API 提供 promise 版本:
¥The finished
API provides promise version:
const { finished } = require('node:stream/promises');
const fs = require('node:fs');
const rs = fs.createReadStream('archive.tar');
async function run() {
await finished(rs);
console.log('Stream is done reading.');
}
run().catch(console.error);
rs.resume(); // Drain the stream.
stream.finished()
在调用 callback
后离开悬空事件监听器(特别是 'error'
、'end'
、'finish'
和 'close'
)。这样做的原因是意外的 'error'
事件(由于不正确的流实现)不会导致意外的崩溃。如果这是不需要的行为,则需要在回调中调用返回的清理函数:
¥stream.finished()
leaves dangling event listeners (in particular
'error'
, 'end'
, 'finish'
and 'close'
) after callback
has been
invoked. The reason for this is so that unexpected 'error'
events (due to
incorrect stream implementations) do not cause unexpected crashes.
If this is unwanted behavior then the returned cleanup function needs to be
invoked in the callback:
const cleanup = finished(rs, (err) => {
cleanup();
// ...
});
stream.pipeline(source[, ...transforms], destination, callback)
#
stream.pipeline(streams, callback)
#
-
streams
<Stream[]> | <Iterable[]> | <AsyncIterable[]> | <Function[]> -
source
<Stream> | <Iterable> | <AsyncIterable> | <Function>-
返回:<Iterable> | <AsyncIterable>
¥Returns: <Iterable> | <AsyncIterable>
-
-
...transforms
<Stream> | <Function>-
source
<AsyncIterable> -
¥Returns: <AsyncIterable>
-
-
destination
<Stream> | <Function>-
source
<AsyncIterable> -
返回:<AsyncIterable> | <Promise>
¥Returns: <AsyncIterable> | <Promise>
-
-
callback
<Function> 当管道完全完成时调用。¥
callback
<Function> Called when the pipeline is fully done.-
err
<Error> -
val
destination
返回的Promise
的解析值。¥
val
Resolved value ofPromise
returned bydestination
.
-
-
返回:<Stream>
¥Returns: <Stream>
一种模块方法,用于在流和生成器之间进行管道转发错误并正确清理并在管道完成时提供回调。
¥A module method to pipe between streams and generators forwarding errors and properly cleaning up and provide a callback when the pipeline is complete.
const { pipeline } = require('node:stream');
const fs = require('node:fs');
const zlib = require('node:zlib');
// Use the pipeline API to easily pipe a series of streams
// together and get notified when the pipeline is fully done.
// A pipeline to gzip a potentially huge tar file efficiently:
pipeline(
fs.createReadStream('archive.tar'),
zlib.createGzip(),
fs.createWriteStream('archive.tar.gz'),
(err) => {
if (err) {
console.error('Pipeline failed.', err);
} else {
console.log('Pipeline succeeded.');
}
}
);
pipeline
API 提供了一个 promise 版本,它还可以接收一个选项参数作为具有 signal
<AbortSignal> 属性的最后一个参数。当信号中止时,将在底层管道上调用 destroy
,并带有 AbortError
。
¥The pipeline
API provides a promise version, which can also
receive an options argument as the last parameter with a
signal
<AbortSignal> property. When the signal is aborted,
destroy
will be called on the underlying pipeline, with an
AbortError
.
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');
const zlib = require('node:zlib');
async function run() {
await pipeline(
fs.createReadStream('archive.tar'),
zlib.createGzip(),
fs.createWriteStream('archive.tar.gz')
);
console.log('Pipeline succeeded.');
}
run().catch(console.error);
要使用 AbortSignal
,请将其作为最后一个参数传递到选项对象中:
¥To use an AbortSignal
, pass it inside an options object,
as the last argument:
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');
const zlib = require('node:zlib');
async function run() {
const ac = new AbortController();
const signal = ac.signal;
setTimeout(() => ac.abort(), 1);
await pipeline(
fs.createReadStream('archive.tar'),
zlib.createGzip(),
fs.createWriteStream('archive.tar.gz'),
{ signal },
);
}
run().catch(console.error); // AbortError
pipeline
API 还支持异步生成器:
¥The pipeline
API also supports async generators:
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');
async function run() {
await pipeline(
fs.createReadStream('lowercase.txt'),
async function* (source, { signal }) {
source.setEncoding('utf8'); // Work with strings rather than `Buffer`s.
for await (const chunk of source) {
yield await processChunk(chunk, { signal });
}
},
fs.createWriteStream('uppercase.txt')
);
console.log('Pipeline succeeded.');
}
run().catch(console.error);
记得处理传入异步生成器的 signal
参数。特别是在异步生成器是管道的来源(即第一个参数)或管道永远不会完成的情况下。
¥Remember to handle the signal
argument passed into the async generator.
Especially in the case where the async generator is the source for the
pipeline (i.e. first argument) or the pipeline will never complete.
const { pipeline } = require('node:stream/promises');
const fs = require('node:fs');
async function run() {
await pipeline(
async function* ({ signal }) {
await someLongRunningfn({ signal });
yield 'asd';
},
fs.createWriteStream('uppercase.txt')
);
console.log('Pipeline succeeded.');
}
run().catch(console.error);
stream.pipeline()
将在所有流上调用 stream.destroy(err)
,除了:
¥stream.pipeline()
will call stream.destroy(err)
on all streams except:
-
已触发
'end'
或'close'
的Readable
流。¥
Readable
streams which have emitted'end'
or'close'
. -
已触发
'finish'
或'close'
的Writable
流。¥
Writable
streams which have emitted'finish'
or'close'
.
在调用 callback
后,stream.pipeline()
在流上留下悬空事件监听器。在失败后重用流的情况下,这可能会导致事件监听器泄漏和吞噬错误。
¥stream.pipeline()
leaves dangling event listeners on the streams
after the callback
has been invoked. In the case of reuse of streams after
failure, this can cause event listener leaks and swallowed errors.
stream.pipeline()
在出现错误时关闭所有流。将 IncomingRequest
与 pipeline
一起使用可能会导致意外行为,因为它会销毁套接字而不发送预期的响应。请参见下面的示例:
¥stream.pipeline()
closes all the streams when an error is raised.
The IncomingRequest
usage with pipeline
could lead to an unexpected behavior
once it would destroy the socket without sending the expected response.
See the example below:
const fs = require('node:fs');
const http = require('node:http');
const { pipeline } = require('node:stream');
const server = http.createServer((req, res) => {
const fileStream = fs.createReadStream('./fileNotExist.txt');
pipeline(fileStream, res, (err) => {
if (err) {
console.log(err); // No such file
// this message can't be sent once `pipeline` already destroyed the socket
return res.end('error!!!');
}
});
});
stream.compose(...streams)
#
-
streams
<Stream[]> | <Iterable[]> | <AsyncIterable[]> | <Function[]> -
¥Returns: <stream.Duplex>
将两个或多个流组合成一个 Duplex
流,该流写入第一个流并从最后一个流读取。每个提供的流都使用 stream.pipeline
通过管道传输到下一个。如果任何流出错,则所有流都将被销毁,包括外部 Duplex
流。
¥Combines two or more streams into a Duplex
stream that writes to the
first stream and reads from the last. Each provided stream is piped into
the next, using stream.pipeline
. If any of the streams error then all
are destroyed, including the outer Duplex
stream.
因为 stream.compose
返回一个新流,该流又可以(并且应该)通过管道传输到其他流中,所以它启用了组合。相反,当将流传递给 stream.pipeline
时,通常第一个流是可读流,最后一个流是可写流,形成一个闭合回路。
¥Because stream.compose
returns a new stream that in turn can (and
should) be piped into other streams, it enables composition. In contrast,
when passing streams to stream.pipeline
, typically the first stream is
a readable stream and the last a writable stream, forming a closed
circuit.
如果传递 Function
,它必须是采用 source
Iterable
的工厂方法。
¥If passed a Function
it must be a factory method taking a source
Iterable
.
import { compose, Transform } from 'node:stream';
const removeSpaces = new Transform({
transform(chunk, encoding, callback) {
callback(null, String(chunk).replace(' ', ''));
}
});
async function* toUpper(source) {
for await (const chunk of source) {
yield String(chunk).toUpperCase();
}
}
let res = '';
for await (const buf of compose(removeSpaces, toUpper).end('hello world')) {
res += buf;
}
console.log(res); // prints 'HELLOWORLD'
stream.compose
可用于将异步迭代器、生成器和函数转换为流。
¥stream.compose
can be used to convert async iterables, generators and
functions into streams.
-
AsyncIterable
转换为可读的Duplex
。无法生成null
。¥
AsyncIterable
converts into a readableDuplex
. Cannot yieldnull
. -
AsyncGeneratorFunction
转换为可读/可写的转换Duplex
。必须将源AsyncIterable
作为第一个参数。无法生成null
。¥
AsyncGeneratorFunction
converts into a readable/writable transformDuplex
. Must take a sourceAsyncIterable
as first parameter. Cannot yieldnull
. -
AsyncFunction
转换为可写的Duplex
。必须返回null
或undefined
。¥
AsyncFunction
converts into a writableDuplex
. Must return eithernull
orundefined
.
import { compose } from 'node:stream';
import { finished } from 'node:stream/promises';
// Convert AsyncIterable into readable Duplex.
const s1 = compose(async function*() {
yield 'Hello';
yield 'World';
}());
// Convert AsyncGenerator into transform Duplex.
const s2 = compose(async function*(source) {
for await (const chunk of source) {
yield String(chunk).toUpperCase();
}
});
let res = '';
// Convert AsyncFunction into writable Duplex.
const s3 = compose(async function(source) {
for await (const chunk of source) {
res += chunk;
}
});
await finished(compose(s1, s2, s3));
console.log(res); // prints 'HELLOWORLD'
stream.Readable.from(iterable[, options])
#
-
iterable
<Iterable> 实现Symbol.asyncIterator
或Symbol.iterator
可迭代协议的对象。如果传递空值,则触发 'error' 事件。¥
iterable
<Iterable> Object implementing theSymbol.asyncIterator
orSymbol.iterator
iterable protocol. Emits an 'error' event if a null value is passed. -
options
<Object> 提供给new stream.Readable([options])
的选项。默认情况下,Readable.from()
会将options.objectMode
设置为true
,除非通过将options.objectMode
设置为false
明确选择退出。¥
options
<Object> Options provided tonew stream.Readable([options])
. By default,Readable.from()
will setoptions.objectMode
totrue
, unless this is explicitly opted out by settingoptions.objectMode
tofalse
. -
¥Returns: <stream.Readable>
用于从迭代器中创建可读流的实用方法。
¥A utility method for creating readable streams out of iterators.
const { Readable } = require('node:stream');
async function * generate() {
yield 'hello';
yield 'streams';
}
const readable = Readable.from(generate());
readable.on('data', (chunk) => {
console.log(chunk);
});
出于性能原因,调用 Readable.from(string)
或 Readable.from(buffer)
不会迭代字符串或缓冲区以匹配其他流语义。
¥Calling Readable.from(string)
or Readable.from(buffer)
will not have
the strings or buffers be iterated to match the other streams semantics
for performance reasons.
stream.Readable.isDisturbed(stream)
#
¥Stability: 1 - Experimental
-
stream
<stream.Readable> | <ReadableStream> -
返回:
boolean
¥Returns:
boolean
返回流是否已被读取或取消。
¥Returns whether the stream has been read from or cancelled.
stream.isErrored(stream)
#
¥Stability: 1 - Experimental
-
stream
<Readable> | <Writable> | <Duplex> | <WritableStream> | <ReadableStream> -
返回:<boolean>
¥Returns: <boolean>
返回流是否遇到错误。
¥Returns whether the stream has encountered an error.
stream.isReadable(stream)
#
¥Stability: 1 - Experimental
-
stream
<Readable> | <Duplex> | <ReadableStream> -
返回:<boolean>
¥Returns: <boolean>
返回流是否可读。
¥Returns whether the stream is readable.
stream.Readable.toWeb(streamReadable)
#
¥Stability: 1 - Experimental
-
streamReadable
<stream.Readable> -
¥Returns: <ReadableStream>
stream.Writable.fromWeb(writableStream[, options])
#
¥Stability: 1 - Experimental
-
writableStream
<WritableStream> -
options
<Object>-
decodeStrings
<boolean> -
highWaterMark
<number> -
objectMode
<boolean> -
signal
<AbortSignal>
-
-
¥Returns: <stream.Writable>
stream.Writable.toWeb(streamWritable)
#
¥Stability: 1 - Experimental
-
streamWritable
<stream.Writable> -
¥Returns: <WritableStream>
stream.Duplex.from(src)
#
src
<Stream> | <Blob> | <ArrayBuffer> | <string> | <Iterable> | <AsyncIterable> | <AsyncGeneratorFunction> | <AsyncFunction> | <Promise> | <Object>
用于创建双工流的实用方法。
¥A utility method for creating duplex streams.
-
Stream
将可写流转换为可写的Duplex
,将可读流转换为Duplex
。¥
Stream
converts writable stream into writableDuplex
and readable stream toDuplex
. -
Blob
转换为可读的Duplex
。¥
Blob
converts into readableDuplex
. -
string
转换为可读的Duplex
。¥
string
converts into readableDuplex
. -
ArrayBuffer
转换为可读的Duplex
。¥
ArrayBuffer
converts into readableDuplex
. -
AsyncIterable
转换为可读的Duplex
。无法生成null
。¥
AsyncIterable
converts into a readableDuplex
. Cannot yieldnull
. -
AsyncGeneratorFunction
转换为可读/可写的转换Duplex
。必须将源AsyncIterable
作为第一个参数。无法生成null
。¥
AsyncGeneratorFunction
converts into a readable/writable transformDuplex
. Must take a sourceAsyncIterable
as first parameter. Cannot yieldnull
. -
AsyncFunction
转换为可写的Duplex
。必须返回null
或undefined
¥
AsyncFunction
converts into a writableDuplex
. Must return eithernull
orundefined
-
Object ({ writable, readable })
将readable
和writable
转换为Stream
,然后将它们组合成Duplex
,其中Duplex
将写入writable
并从readable
读取。¥
Object ({ writable, readable })
convertsreadable
andwritable
intoStream
and then combines them intoDuplex
where theDuplex
will write to thewritable
and read from thereadable
. -
Promise
转换为可读的Duplex
。忽略值null
。¥
Promise
converts into readableDuplex
. Valuenull
is ignored. -
¥Returns: <stream.Duplex>
stream.addAbortSignal(signal, stream)
#
-
signal
<AbortSignal> 代表可能取消的信号¥
signal
<AbortSignal> A signal representing possible cancellation -
stream
<Stream> 附加信号的流¥
stream
<Stream> a stream to attach a signal to
将 AbortSignal 附加到可读或可写流。这允许代码使用 AbortController
控制流销毁。
¥Attaches an AbortSignal to a readable or writeable stream. This lets code
control stream destruction using an AbortController
.
在与传递的 AbortSignal
对应的 AbortController
上调用 abort
的行为与在流上调用 .destroy(new AbortError())
的行为相同。
¥Calling abort
on the AbortController
corresponding to the passed
AbortSignal
will behave the same way as calling .destroy(new AbortError())
on the stream.
const fs = require('node:fs');
const controller = new AbortController();
const read = addAbortSignal(
controller.signal,
fs.createReadStream(('object.json'))
);
// Later, abort the operation closing the stream
controller.abort();
或者使用带有可读流的 AbortSignal
作为异步可迭代对象:
¥Or using an AbortSignal
with a readable stream as an async iterable:
const controller = new AbortController();
setTimeout(() => controller.abort(), 10_000); // set a timeout
const stream = addAbortSignal(
controller.signal,
fs.createReadStream(('object.json'))
);
(async () => {
try {
for await (const chunk of stream) {
await process(chunk);
}
} catch (e) {
if (e.name === 'AbortError') {
// The operation was cancelled
} else {
throw e;
}
}
})();
流实现者的 API#
¥API for stream implementers
node:stream
模块 API 旨在使使用 JavaScript 的原型继承模型轻松实现流成为可能。
¥The node:stream
module API has been designed to make it possible to easily
implement streams using JavaScript's prototypal inheritance model.
首先,流开发者会声明一个新的 JavaScript 类,它扩展四个基本流类(stream.Writable
、stream.Readable
、stream.Duplex
或 stream.Transform
)之一,确保它们调用适当的父类构造函数:
¥First, a stream developer would declare a new JavaScript class that extends one
of the four basic stream classes (stream.Writable
, stream.Readable
,
stream.Duplex
, or stream.Transform
), making sure they call the appropriate
parent class constructor:
const { Writable } = require('node:stream');
class MyWritable extends Writable {
constructor({ highWaterMark, ...options }) {
super({ highWaterMark });
// ...
}
}
扩展流时,请记住在将这些选项转发给基本构造函数之前用户可以并且应该提供哪些选项。例如,如果实现对 autoDestroy
和 emitClose
选项做出假设,则不允许用户覆盖这些。明确转发哪些选项,而不是隐式转发所有选项。
¥When extending streams, keep in mind what options the user
can and should provide before forwarding these to the base constructor. For
example, if the implementation makes assumptions in regard to the
autoDestroy
and emitClose
options, do not allow the
user to override these. Be explicit about what
options are forwarded instead of implicitly forwarding all options.
然后,新的流类必须实现一个或多个特定方法,具体取决于正在创建的流的类型,如下表所详述:
¥The new stream class must then implement one or more specific methods, depending on the type of stream being created, as detailed in the chart below:
用例 | 类 | 实现方法 |
---|---|---|
只读 | Readable | _read() |
只写 | Writable | _write() , _writev() , _final() |
读写 | Duplex | _read() , _write() , _writev() , _final() |
对写入的数据进行操作,然后读取结果 | Transform | _transform() , _flush() , _final() |
流的实现代码不应该调用旨在供消费者使用的流的 "public" 方法(如 流消费者的 API 部分所述)。这样做可能会对使用流的应用代码产生不利的副作用。
¥The implementation code for a stream should never call the "public" methods of a stream that are intended for use by consumers (as described in the API for stream consumers section). Doing so may lead to adverse side effects in application code consuming the stream.
避免覆盖 write()
、end()
、cork()
、uncork()
、read()
和 destroy()
等公共方法,或触发 'error'
、'data'
、'end'
、'finish'
和 'close'
到 .emit()
等内部事件。这样做会销毁当前和未来的流不变量,从而导致与其他流、流实用程序和用户期望的行为和/或兼容性问题。
¥Avoid overriding public methods such as write()
, end()
, cork()
,
uncork()
, read()
and destroy()
, or emitting internal events such
as 'error'
, 'data'
, 'end'
, 'finish'
and 'close'
through .emit()
.
Doing so can break current and future stream invariants leading to behavior
and/or compatibility issues with other streams, stream utilities, and user
expectations.
简化结构#
¥Simplified construction
对于许多简单的情况,可以在不依赖继承的情况下创建流。这可以通过直接创建 stream.Writable
、stream.Readable
、stream.Duplex
或 stream.Transform
对象的实例并将适当的方法作为构造函数选项传递来实现。
¥For many simple cases, it is possible to create a stream without relying on
inheritance. This can be accomplished by directly creating instances of the
stream.Writable
, stream.Readable
, stream.Duplex
, or stream.Transform
objects and passing appropriate methods as constructor options.
const { Writable } = require('node:stream');
const myWritable = new Writable({
construct(callback) {
// Initialize state and load resources...
},
write(chunk, encoding, callback) {
// ...
},
destroy() {
// Free resources...
}
});
实现可写流#
¥Implementing a writable stream
stream.Writable
类被扩展以实现 Writable
流。
¥The stream.Writable
class is extended to implement a Writable
stream.
自定义 Writable
流必须调用 new stream.Writable([options])
构造函数并实现 writable._write()
和/或 writable._writev()
方法。
¥Custom Writable
streams must call the new stream.Writable([options])
constructor and implement the writable._write()
and/or writable._writev()
method.
new stream.Writable([options])
#
-
options
<Object>-
highWaterMark
<number>stream.write()
开始返回false
时的缓冲级别。默认值:16384
(16 KiB),或16
用于objectMode
流。¥
highWaterMark
<number> Buffer level whenstream.write()
starts returningfalse
. Default:16384
(16 KiB), or16
forobjectMode
streams. -
decodeStrings
<boolean> 是否将传递给stream.write()
的string
编码为Buffer
(使用stream.write()
调用中指定的编码),然后再将它们传递给stream._write()
。不转换其他类型的数据(即Buffer
不解码为string
)。设置为 false 将阻止string
被转换。默认值:true
。¥
decodeStrings
<boolean> Whether to encodestring
s passed tostream.write()
toBuffer
s (with the encoding specified in thestream.write()
call) before passing them tostream._write()
. Other types of data are not converted (i.e.Buffer
s are not decoded intostring
s). Setting to false will preventstring
s from being converted. Default:true
. -
defaultEncoding
<string> 当没有将编码指定为stream.write()
的参数时使用的默认编码。默认值:'utf8'
。¥
defaultEncoding
<string> The default encoding that is used when no encoding is specified as an argument tostream.write()
. Default:'utf8'
. -
objectMode
<boolean>stream.write(anyObj)
是否为有效操作。设置后,如果流实现支持,则可以写入字符串、Buffer
或Uint8Array
以外的 JavaScript 值。默认值:false
。¥
objectMode
<boolean> Whether or not thestream.write(anyObj)
is a valid operation. When set, it becomes possible to write JavaScript values other than string,Buffer
orUint8Array
if supported by the stream implementation. Default:false
. -
emitClose
<boolean> 流被销毁后是否应该触发'close'
。默认值:true
。¥
emitClose
<boolean> Whether or not the stream should emit'close'
after it has been destroyed. Default:true
. -
write
<Function>stream._write()
方法的实现。¥
write
<Function> Implementation for thestream._write()
method. -
writev
<Function>stream._writev()
方法的实现。¥
writev
<Function> Implementation for thestream._writev()
method. -
destroy
<Function>stream._destroy()
方法的实现。¥
destroy
<Function> Implementation for thestream._destroy()
method. -
final
<Function>stream._final()
方法的实现。¥
final
<Function> Implementation for thestream._final()
method. -
construct
<Function>stream._construct()
方法的实现。¥
construct
<Function> Implementation for thestream._construct()
method. -
autoDestroy
<boolean> 此流是否应在结束后自动调用自身的.destroy()
。默认值:true
。¥
autoDestroy
<boolean> Whether this stream should automatically call.destroy()
on itself after ending. Default:true
. -
signal
<AbortSignal> 表示可能取消的信号。¥
signal
<AbortSignal> A signal representing possible cancellation.
-
const { Writable } = require('node:stream');
class MyWritable extends Writable {
constructor(options) {
// Calls the stream.Writable() constructor.
super(options);
// ...
}
}
或者,当使用 ES6 之前的样式构造函数时:
¥Or, when using pre-ES6 style constructors:
const { Writable } = require('node:stream');
const util = require('node:util');
function MyWritable(options) {
if (!(this instanceof MyWritable))
return new MyWritable(options);
Writable.call(this, options);
}
util.inherits(MyWritable, Writable);
或者,使用简化的构造函数方法:
¥Or, using the simplified constructor approach:
const { Writable } = require('node:stream');
const myWritable = new Writable({
write(chunk, encoding, callback) {
// ...
},
writev(chunks, callback) {
// ...
}
});
在对应于传递的 AbortSignal
的 AbortController
上调用 abort
的行为方式与在可写流上调用 .destroy(new AbortError())
的方式相同。
¥Calling abort
on the AbortController
corresponding to the passed
AbortSignal
will behave the same way as calling .destroy(new AbortError())
on the writeable stream.
const { Writable } = require('node:stream');
const controller = new AbortController();
const myWritable = new Writable({
write(chunk, encoding, callback) {
// ...
},
writev(chunks, callback) {
// ...
},
signal: controller.signal
});
// Later, abort the operation closing the stream
controller.abort();
writable._construct(callback)
#
-
callback
<Function> 当流完成初始化时调用此函数(可选地带有错误参数)。¥
callback
<Function> Call this function (optionally with an error argument) when the stream has finished initializing.
不得直接调用 _construct()
方法。它可能由子类实现,如果是这样,将仅由内部 Writable
类方法调用。
¥The _construct()
method MUST NOT be called directly. It may be implemented
by child classes, and if so, will be called by the internal Writable
class methods only.
这个可选函数将在流构造函数返回后立即调用,延迟任何 _write()
、_final()
和 _destroy()
调用,直到调用 callback
。这对于在使用流之前初始化状态或异步初始化资源很有用。
¥This optional function will be called in a tick after the stream constructor
has returned, delaying any _write()
, _final()
and _destroy()
calls until
callback
is called. This is useful to initialize state or asynchronously
initialize resources before the stream can be used.
const { Writable } = require('node:stream');
const fs = require('node:fs');
class WriteStream extends Writable {
constructor(filename) {
super();
this.filename = filename;
this.fd = null;
}
_construct(callback) {
fs.open(this.filename, (err, fd) => {
if (err) {
callback(err);
} else {
this.fd = fd;
callback();
}
});
}
_write(chunk, encoding, callback) {
fs.write(this.fd, chunk, callback);
}
_destroy(err, callback) {
if (this.fd) {
fs.close(this.fd, (er) => callback(er || err));
} else {
callback(err);
}
}
}
writable._write(chunk, encoding, callback)
#
-
chunk
<Buffer> | <string> | <any> 要写入的Buffer
,从string
转换为stream.write()
。如果流的decodeStrings
选项是false
或者流在对象模式下运行,则块将不会被转换并且将是传递给stream.write()
的任何内容。¥
chunk
<Buffer> | <string> | <any> TheBuffer
to be written, converted from thestring
passed tostream.write()
. If the stream'sdecodeStrings
option isfalse
or the stream is operating in object mode, the chunk will not be converted & will be whatever was passed tostream.write()
. -
encoding
<string> 如果块是字符串,则encoding
是该字符串的字符编码。如果块是Buffer
,或者如果流以对象模式运行,则encoding
可能会被忽略。¥
encoding
<string> If the chunk is a string, thenencoding
is the character encoding of that string. If chunk is aBuffer
, or if the stream is operating in object mode,encoding
may be ignored. -
callback
<Function> 当对提供的块的处理完成时调用此函数(可选地带有错误参数)。¥
callback
<Function> Call this function (optionally with an error argument) when processing is complete for the supplied chunk.
所有 Writable
流实现都必须提供 writable._write()
和/或 writable._writev()
方法来将数据发送到底层资源。
¥All Writable
stream implementations must provide a
writable._write()
and/or
writable._writev()
method to send data to the underlying
resource.
Transform
流提供了它们自己的 writable._write()
实现。
¥Transform
streams provide their own implementation of the
writable._write()
.
此函数不得由应用代码直接调用。它应该由子类实现,并且只能由内部 Writable
类方法调用。
¥This function MUST NOT be called by application code directly. It should be
implemented by child classes, and called by the internal Writable
class
methods only.
callback
函数必须在 writable._write()
内部同步调用或异步调用(即不同的时钟周期),以触发写入成功完成或因错误而失败的信号。如果调用失败,传递给 callback
的第一个参数必须是 Error
对象,如果写入成功,则必须是 null
。
¥The callback
function must be called synchronously inside of
writable._write()
or asynchronously (i.e. different tick) to signal either
that the write completed successfully or failed with an error.
The first argument passed to the callback
must be the Error
object if the
call failed or null
if the write succeeded.
在调用 writable._write()
和调用 callback
之间发生的对 writable.write()
的所有调用都会导致写入的数据被缓冲。调用 callback
时,流可能会触发 'drain'
事件。如果流实现能够一次处理多个数据块,则应实现 writable._writev()
方法。
¥All calls to writable.write()
that occur between the time writable._write()
is called and the callback
is called will cause the written data to be
buffered. When the callback
is invoked, the stream might emit a 'drain'
event. If a stream implementation is capable of processing multiple chunks of
data at once, the writable._writev()
method should be implemented.
如果在构造函数选项中将 decodeStrings
属性显式设置为 false
,则 chunk
将保持传递给 .write()
的同一对象,并且可能是字符串而不是 Buffer
。这是为了支持对某些字符串数据编码进行优化处理的实现。在这种情况下,encoding
参数将指示字符串的字符编码。否则,可以安全地忽略 encoding
参数。
¥If the decodeStrings
property is explicitly set to false
in the constructor
options, then chunk
will remain the same object that is passed to .write()
,
and may be a string rather than a Buffer
. This is to support implementations
that have an optimized handling for certain string data encodings. In that case,
the encoding
argument will indicate the character encoding of the string.
Otherwise, the encoding
argument can be safely ignored.
writable._write()
方法带有下划线前缀,因为它是定义它的类的内部方法,不应由用户程序直接调用。
¥The writable._write()
method is prefixed with an underscore because it is
internal to the class that defines it, and should never be called directly by
user programs.
writable._writev(chunks, callback)
#
-
chunks
<Object[]> 要写入的数据。该值是一个 <Object> 数组,每个数组代表要写入的离散数据块。这些对象的属性是:¥
chunks
<Object[]> The data to be written. The value is an array of <Object> that each represent a discrete chunk of data to write. The properties of these objects are:-
chunk
<Buffer> | <string> 包含要写入的数据的缓冲区实例或字符串。如果创建Writable
时将decodeStrings
选项设置为false
并将字符串传递给write()
,则chunk
将是一个字符串。¥
chunk
<Buffer> | <string> A buffer instance or string containing the data to be written. Thechunk
will be a string if theWritable
was created with thedecodeStrings
option set tofalse
and a string was passed towrite()
. -
encoding
<string>chunk
的字符编码。如果chunk
是Buffer
,则encoding
将是'buffer'
。¥
encoding
<string> The character encoding of thechunk
. Ifchunk
is aBuffer
, theencoding
will be'buffer'
.
-
-
callback
<Function> 当对提供的块的处理完成时要调用的回调函数(可选地带有错误参数)。¥
callback
<Function> A callback function (optionally with an error argument) to be invoked when processing is complete for the supplied chunks.
此函数不得由应用代码直接调用。它应该由子类实现,并且只能由内部 Writable
类方法调用。
¥This function MUST NOT be called by application code directly. It should be
implemented by child classes, and called by the internal Writable
class
methods only.
writable._writev()
方法可以在能够一次处理多个数据块的流实现中作为 writable._write()
的补充或替代方法来实现。如果实现并且有来自先前写入的缓冲数据,则将调用 _writev()
而不是 _write()
。
¥The writable._writev()
method may be implemented in addition or alternatively
to writable._write()
in stream implementations that are capable of processing
multiple chunks of data at once. If implemented and if there is buffered data
from previous writes, _writev()
will be called instead of _write()
.
writable._writev()
方法带有下划线前缀,因为它是定义它的类的内部方法,不应由用户程序直接调用。
¥The writable._writev()
method is prefixed with an underscore because it is
internal to the class that defines it, and should never be called directly by
user programs.
writable._destroy(err, callback)
#
-
err
<Error> 可能的错误。¥
err
<Error> A possible error. -
callback
<Function> 采用可选的错误参数的回调函数。¥
callback
<Function> A callback function that takes an optional error argument.
_destroy()
方法被 writable.destroy()
调用。它可以被子类覆盖,但不能直接调用。此外,callback
不应与 async/await 混合使用,一旦它在 promise 被解析时执行。
¥The _destroy()
method is called by writable.destroy()
.
It can be overridden by child classes but it must not be called directly.
Furthermore, the callback
should not be mixed with async/await
once it is executed when a promise is resolved.
writable._final(callback)
#
-
callback
<Function> 完成写入任何剩余数据后调用此函数(可选地带有错误参数)。¥
callback
<Function> Call this function (optionally with an error argument) when finished writing any remaining data.
不得直接调用 _final()
方法。它可能由子类实现,如果是这样,将仅由内部 Writable
类方法调用。
¥The _final()
method must not be called directly. It may be implemented
by child classes, and if so, will be called by the internal Writable
class methods only.
这个可选函数将在流关闭之前被调用,延迟 'finish'
事件直到 callback
被调用。这对于在流结束之前关闭资源或写入缓冲数据很有用。
¥This optional function will be called before the stream closes, delaying the
'finish'
event until callback
is called. This is useful to close resources
or write buffered data before a stream ends.
写入时出错#
¥Errors while writing
在处理 writable._write()
、writable._writev()
和 writable._final()
方法期间发生的错误必须通过调用回调并将错误作为第一个参数传递来传播。从这些方法中抛出 Error
或手动触发 'error'
事件会导致未定义的行为。
¥Errors occurring during the processing of the writable._write()
,
writable._writev()
and writable._final()
methods must be propagated
by invoking the callback and passing the error as the first argument.
Throwing an Error
from within these methods or manually emitting an 'error'
event results in undefined behavior.
如果 Readable
流在 Writable
触发错误时通过管道传输到 Writable
流,则 Readable
流将被取消传输。
¥If a Readable
stream pipes into a Writable
stream when Writable
emits an
error, the Readable
stream will be unpiped.
const { Writable } = require('node:stream');
const myWritable = new Writable({
write(chunk, encoding, callback) {
if (chunk.toString().indexOf('a') >= 0) {
callback(new Error('chunk is invalid'));
} else {
callback();
}
}
});
可写流示例#
¥An example writable stream
下面说明了一个相当简单(并且有些毫无意义)的自定义 Writable
流实现。虽然这个特定的 Writable
流实例没有任何真正特别的用处,但该示例说明了自定义 Writable
流实例的每个必需元素:
¥The following illustrates a rather simplistic (and somewhat pointless) custom
Writable
stream implementation. While this specific Writable
stream instance
is not of any real particular usefulness, the example illustrates each of the
required elements of a custom Writable
stream instance:
const { Writable } = require('node:stream');
class MyWritable extends Writable {
_write(chunk, encoding, callback) {
if (chunk.toString().indexOf('a') >= 0) {
callback(new Error('chunk is invalid'));
} else {
callback();
}
}
}
可写流中的解码缓冲区#
¥Decoding buffers in a writable stream
解码缓冲区是一项常见任务,例如,在使用输入为字符串的转换器时。当使用多字节字符编码(例如 UTF-8)时,这不是一个简单的过程。以下示例显示如何使用 StringDecoder
和 Writable
解码多字节字符串。
¥Decoding buffers is a common task, for instance, when using transformers whose
input is a string. This is not a trivial process when using multi-byte
characters encoding, such as UTF-8. The following example shows how to decode
multi-byte strings using StringDecoder
and Writable
.
const { Writable } = require('node:stream');
const { StringDecoder } = require('node:string_decoder');
class StringWritable extends Writable {
constructor(options) {
super(options);
this._decoder = new StringDecoder(options && options.defaultEncoding);
this.data = '';
}
_write(chunk, encoding, callback) {
if (encoding === 'buffer') {
chunk = this._decoder.write(chunk);
}
this.data += chunk;
callback();
}
_final(callback) {
this.data += this._decoder.end();
callback();
}
}
const euro = [[0xE2, 0x82], [0xAC]].map(Buffer.from);
const w = new StringWritable();
w.write('currency: ');
w.write(euro[0]);
w.end(euro[1]);
console.log(w.data); // currency: €
实现可读流#
¥Implementing a readable stream
stream.Readable
类被扩展以实现 Readable
流。
¥The stream.Readable
class is extended to implement a Readable
stream.
自定义 Readable
流必须调用 new stream.Readable([options])
构造函数并实现 readable._read()
方法。
¥Custom Readable
streams must call the new stream.Readable([options])
constructor and implement the readable._read()
method.
new stream.Readable([options])
#
-
options
<Object>-
highWaterMark
<number> 在停止从底层资源读取之前存储在内部缓冲区中的最大 字节数。默认值:16384
(16 KiB),或16
用于objectMode
流。¥
highWaterMark
<number> The maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource. Default:16384
(16 KiB), or16
forobjectMode
streams. -
encoding
<string> 如果指定,则缓冲区将使用指定的编码解码为字符串。默认值:null
。¥
encoding
<string> If specified, then buffers will be decoded to strings using the specified encoding. Default:null
. -
objectMode
<boolean> 此流是否应表现为对象流。这意味着stream.read(n)
返回单个值,而不是大小为n
的Buffer
。默认值:false
。¥
objectMode
<boolean> Whether this stream should behave as a stream of objects. Meaning thatstream.read(n)
returns a single value instead of aBuffer
of sizen
. Default:false
. -
emitClose
<boolean> 流被销毁后是否应该触发'close'
。默认值:true
。¥
emitClose
<boolean> Whether or not the stream should emit'close'
after it has been destroyed. Default:true
. -
read
<Function>stream._read()
方法的实现。¥
read
<Function> Implementation for thestream._read()
method. -
destroy
<Function>stream._destroy()
方法的实现。¥
destroy
<Function> Implementation for thestream._destroy()
method. -
construct
<Function>stream._construct()
方法的实现。¥
construct
<Function> Implementation for thestream._construct()
method. -
autoDestroy
<boolean> 此流是否应在结束后自动调用自身的.destroy()
。默认值:true
。¥
autoDestroy
<boolean> Whether this stream should automatically call.destroy()
on itself after ending. Default:true
. -
signal
<AbortSignal> 表示可能取消的信号。¥
signal
<AbortSignal> A signal representing possible cancellation.
-
const { Readable } = require('node:stream');
class MyReadable extends Readable {
constructor(options) {
// Calls the stream.Readable(options) constructor.
super(options);
// ...
}
}
或者,当使用 ES6 之前的样式构造函数时:
¥Or, when using pre-ES6 style constructors:
const { Readable } = require('node:stream');
const util = require('node:util');
function MyReadable(options) {
if (!(this instanceof MyReadable))
return new MyReadable(options);
Readable.call(this, options);
}
util.inherits(MyReadable, Readable);
或者,使用简化的构造函数方法:
¥Or, using the simplified constructor approach:
const { Readable } = require('node:stream');
const myReadable = new Readable({
read(size) {
// ...
}
});
在对应于传递的 AbortSignal
的 AbortController
上调用 abort
的行为方式与在创建的可读对象上调用 .destroy(new AbortError())
的方式相同。
¥Calling abort
on the AbortController
corresponding to the passed
AbortSignal
will behave the same way as calling .destroy(new AbortError())
on the readable created.
const { Readable } = require('node:stream');
const controller = new AbortController();
const read = new Readable({
read(size) {
// ...
},
signal: controller.signal
});
// Later, abort the operation closing the stream
controller.abort();
readable._construct(callback)
#
-
callback
<Function> 当流完成初始化时调用此函数(可选地带有错误参数)。¥
callback
<Function> Call this function (optionally with an error argument) when the stream has finished initializing.
不得直接调用 _construct()
方法。它可能由子类实现,如果是这样,将仅由内部 Readable
类方法调用。
¥The _construct()
method MUST NOT be called directly. It may be implemented
by child classes, and if so, will be called by the internal Readable
class methods only.
这个可选函数将被流构造函数安排在下一个时钟周期,延迟任何 _read()
和 _destroy()
调用,直到调用 callback
。这对于在使用流之前初始化状态或异步初始化资源很有用。
¥This optional function will be scheduled in the next tick by the stream
constructor, delaying any _read()
and _destroy()
calls until callback
is
called. This is useful to initialize state or asynchronously initialize
resources before the stream can be used.
const { Readable } = require('node:stream');
const fs = require('node:fs');
class ReadStream extends Readable {
constructor(filename) {
super();
this.filename = filename;
this.fd = null;
}
_construct(callback) {
fs.open(this.filename, (err, fd) => {
if (err) {
callback(err);
} else {
this.fd = fd;
callback();
}
});
}
_read(n) {
const buf = Buffer.alloc(n);
fs.read(this.fd, buf, 0, n, null, (err, bytesRead) => {
if (err) {
this.destroy(err);
} else {
this.push(bytesRead > 0 ? buf.slice(0, bytesRead) : null);
}
});
}
_destroy(err, callback) {
if (this.fd) {
fs.close(this.fd, (er) => callback(er || err));
} else {
callback(err);
}
}
}
readable._read(size)
#
此函数不得由应用代码直接调用。它应该由子类实现,并且只能由内部 Readable
类方法调用。
¥This function MUST NOT be called by application code directly. It should be
implemented by child classes, and called by the internal Readable
class
methods only.
所有 Readable
流实现都必须提供 readable._read()
方法的实现以从底层资源中获取数据。
¥All Readable
stream implementations must provide an implementation of the
readable._read()
method to fetch data from the underlying resource.
调用 readable._read()
时,如果资源中有可用数据,则实现应开始使用 this.push(dataChunk)
方法将该数据推入读取队列。一旦流准备好接受更多数据,则 _read()
将在每次调用 this.push(dataChunk)
后再次调用。_read()
可能会继续从资源中读取并推送数据,直到 readable.push()
返回 false
。只有在停止后再次调用 _read()
时,它才会继续将额外的数据推入队列。
¥When readable._read()
is called, if data is available from the resource,
the implementation should begin pushing that data into the read queue using the
this.push(dataChunk)
method. _read()
will be called again
after each call to this.push(dataChunk)
once the stream is
ready to accept more data. _read()
may continue reading from the resource and
pushing data until readable.push()
returns false
. Only when _read()
is
called again after it has stopped should it resume pushing additional data into
the queue.
一旦调用了 readable._read()
方法,将不会再次调用它,直到通过 readable.push()
方法推送更多数据。空缓冲区和字符串等空数据不会导致调用 readable._read()
。
¥Once the readable._read()
method has been called, it will not be called
again until more data is pushed through the readable.push()
method. Empty data such as empty buffers and strings will not cause
readable._read()
to be called.
size
参数是建议性的。对于 "read" 是返回数据的单个操作的实现,可以使用 size
参数来确定要获取多少数据。其他实现可能会忽略此参数,并在数据可用时简单地提供数据。在调用 stream.push(chunk)
之前 size
字节可用之前,不需要 "wait"。
¥The size
argument is advisory. For implementations where a "read" is a
single operation that returns data can use the size
argument to determine how
much data to fetch. Other implementations may ignore this argument and simply
provide data whenever it becomes available. There is no need to "wait" until
size
bytes are available before calling stream.push(chunk)
.
readable._read()
方法带有下划线前缀,因为它是定义它的类的内部方法,不应由用户程序直接调用。
¥The readable._read()
method is prefixed with an underscore because it is
internal to the class that defines it, and should never be called directly by
user programs.
readable._destroy(err, callback)
#
-
err
<Error> 可能的错误。¥
err
<Error> A possible error. -
callback
<Function> 采用可选的错误参数的回调函数。¥
callback
<Function> A callback function that takes an optional error argument.
_destroy()
方法被 readable.destroy()
调用。它可以被子类覆盖,但不能直接调用。
¥The _destroy()
method is called by readable.destroy()
.
It can be overridden by child classes but it must not be called directly.
readable.push(chunk[, encoding])
#
-
chunk
<Buffer> | <Uint8Array> | <string> | <null> | <any> 要推入读取队列的数据块。对于不在对象模式下操作的流,chunk
必须是字符串、Buffer
或Uint8Array
。对于对象模式流,chunk
可以是任何 JavaScript 值。¥
chunk
<Buffer> | <Uint8Array> | <string> | <null> | <any> Chunk of data to push into the read queue. For streams not operating in object mode,chunk
must be a string,Buffer
orUint8Array
. For object mode streams,chunk
may be any JavaScript value. -
encoding
<string> 字符串块的编码。必须是有效的Buffer
编码,例如'utf8'
或'ascii'
。¥
encoding
<string> Encoding of string chunks. Must be a validBuffer
encoding, such as'utf8'
or'ascii'
. -
返回:<boolean>
true
如果可以继续推送额外的数据块;false
否则。¥Returns: <boolean>
true
if additional chunks of data may continue to be pushed;false
otherwise.
当 chunk
为 Buffer
、Uint8Array
、string
时,会将数据的 chunk
加入内部队列,供流用户消费。将 chunk
作为 null
传递表示流结束 (EOF),之后无法写入更多数据。
¥When chunk
is a Buffer
, Uint8Array
, or string
, the chunk
of data will
be added to the internal queue for users of the stream to consume.
Passing chunk
as null
signals the end of the stream (EOF), after which no
more data can be written.
当 Readable
运行在 paused 模式时,在 'readable'
事件触发时调用 readable.read()
方法可以读出 readable.push()
添加的数据。
¥When the Readable
is operating in paused mode, the data added with
readable.push()
can be read out by calling the
readable.read()
method when the 'readable'
event is
emitted.
当 Readable
在流动模式下运行时,添加了 readable.push()
的数据将通过触发 'data'
事件来传递。
¥When the Readable
is operating in flowing mode, the data added with
readable.push()
will be delivered by emitting a 'data'
event.
readable.push()
方法被设计为尽可能灵活。例如,当封装提供某种形式的暂停/恢复机制和数据回调的底层源时,底层源可以由自定义 Readable
实例封装:
¥The readable.push()
method is designed to be as flexible as possible. For
example, when wrapping a lower-level source that provides some form of
pause/resume mechanism, and a data callback, the low-level source can be wrapped
by the custom Readable
instance:
// `_source` is an object with readStop() and readStart() methods,
// and an `ondata` member that gets called when it has data, and
// an `onend` member that gets called when the data is over.
class SourceWrapper extends Readable {
constructor(options) {
super(options);
this._source = getLowLevelSourceObject();
// Every time there's data, push it into the internal buffer.
this._source.ondata = (chunk) => {
// If push() returns false, then stop reading from source.
if (!this.push(chunk))
this._source.readStop();
};
// When the source ends, push the EOF-signaling `null` chunk.
this._source.onend = () => {
this.push(null);
};
}
// _read() will be called when the stream wants to pull more data in.
// The advisory size argument is ignored in this case.
_read(size) {
this._source.readStart();
}
}
readable.push()
方法用于将内容推入内部缓冲区。可以用 readable._read()
方法驱动。
¥The readable.push()
method is used to push the content
into the internal buffer. It can be driven by the readable._read()
method.
对于非对象模式运行的流,如果 readable.push()
的 chunk
参数为 undefined
,将被视为空字符串或缓冲区。有关详细信息,请参阅 readable.push('')
。
¥For streams not operating in object mode, if the chunk
parameter of
readable.push()
is undefined
, it will be treated as empty string or
buffer. See readable.push('')
for more information.
读取时出错#
¥Errors while reading
在处理 readable._read()
期间发生的错误必须通过 readable.destroy(err)
方法传播。从 readable._read()
中抛出 Error
或手动触发 'error'
事件会导致未定义的行为。
¥Errors occurring during processing of the readable._read()
must be
propagated through the readable.destroy(err)
method.
Throwing an Error
from within readable._read()
or manually emitting an
'error'
event results in undefined behavior.
const { Readable } = require('node:stream');
const myReadable = new Readable({
read(size) {
const err = checkSomeErrorCondition();
if (err) {
this.destroy(err);
} else {
// Do some work.
}
}
});
计数流示例#
¥An example counting stream
以下是 Readable
流的基本示例,它按升序触发从 1 到 1,000,000 的数字,然后结束。
¥The following is a basic example of a Readable
stream that emits the numerals
from 1 to 1,000,000 in ascending order, and then ends.
const { Readable } = require('node:stream');
class Counter extends Readable {
constructor(opt) {
super(opt);
this._max = 1000000;
this._index = 1;
}
_read() {
const i = this._index++;
if (i > this._max)
this.push(null);
else {
const str = String(i);
const buf = Buffer.from(str, 'ascii');
this.push(buf);
}
}
}
实现双工流#
¥Implementing a duplex stream
Duplex
流是同时实现 Readable
和 Writable
的流,例如 TCP 套接字连接。
¥A Duplex
stream is one that implements both Readable
and
Writable
, such as a TCP socket connection.
因为 JavaScript 不支持多重继承,所以扩展 stream.Duplex
类以实现 Duplex
流(与扩展 stream.Readable
和 stream.Writable
类相反)。
¥Because JavaScript does not have support for multiple inheritance, the
stream.Duplex
class is extended to implement a Duplex
stream (as opposed
to extending the stream.Readable
and stream.Writable
classes).
stream.Duplex
类原型继承自 stream.Readable
并寄生于 stream.Writable
,但由于在 stream.Writable
上覆盖了 Symbol.hasInstance
,instanceof
将适用于两个基类。
¥The stream.Duplex
class prototypically inherits from stream.Readable
and
parasitically from stream.Writable
, but instanceof
will work properly for
both base classes due to overriding Symbol.hasInstance
on
stream.Writable
.
自定义 Duplex
流必须调用 new stream.Duplex([options])
构造函数并实现 readable._read()
和 writable._write()
方法。
¥Custom Duplex
streams must call the new stream.Duplex([options])
constructor and implement both the readable._read()
and
writable._write()
methods.
new stream.Duplex(options)
#
-
options
<Object> 传给Writable
和Readable
构造函数。还有以下字段:¥
options
<Object> Passed to bothWritable
andReadable
constructors. Also has the following fields:-
allowHalfOpen
<boolean> 如果设置为false
,则流将在可读端结束时自动结束可写端。默认值:true
。¥
allowHalfOpen
<boolean> If set tofalse
, then the stream will automatically end the writable side when the readable side ends. Default:true
. -
readable
<boolean> 设置Duplex
是否可读。默认值:true
。¥
readable
<boolean> Sets whether theDuplex
should be readable. Default:true
. -
writable
<boolean> 设置Duplex
是否可写。默认值:true
。¥
writable
<boolean> Sets whether theDuplex
should be writable. Default:true
. -
readableObjectMode
<boolean> 为流的可读端设置objectMode
。如果objectMode
为true
,则无效。默认值:false
。¥
readableObjectMode
<boolean> SetsobjectMode
for readable side of the stream. Has no effect ifobjectMode
istrue
. Default:false
. -
writableObjectMode
<boolean> 为流的可写端设置objectMode
。如果objectMode
为true
,则无效。默认值:false
。¥
writableObjectMode
<boolean> SetsobjectMode
for writable side of the stream. Has no effect ifobjectMode
istrue
. Default:false
. -
readableHighWaterMark
<number> 为流的可读端设置highWaterMark
。如果提供highWaterMark
,则无效。¥
readableHighWaterMark
<number> SetshighWaterMark
for the readable side of the stream. Has no effect ifhighWaterMark
is provided. -
writableHighWaterMark
<number> 为流的可写端设置highWaterMark
。如果提供highWaterMark
,则无效。¥
writableHighWaterMark
<number> SetshighWaterMark
for the writable side of the stream. Has no effect ifhighWaterMark
is provided.
-
const { Duplex } = require('node:stream');
class MyDuplex extends Duplex {
constructor(options) {
super(options);
// ...
}
}
或者,当使用 ES6 之前的样式构造函数时:
¥Or, when using pre-ES6 style constructors:
const { Duplex } = require('node:stream');
const util = require('node:util');
function MyDuplex(options) {
if (!(this instanceof MyDuplex))
return new MyDuplex(options);
Duplex.call(this, options);
}
util.inherits(MyDuplex, Duplex);
或者,使用简化的构造函数方法:
¥Or, using the simplified constructor approach:
const { Duplex } = require('node:stream');
const myDuplex = new Duplex({
read(size) {
// ...
},
write(chunk, encoding, callback) {
// ...
}
});
使用管道时:
¥When using pipeline:
const { Transform, pipeline } = require('node:stream');
const fs = require('node:fs');
pipeline(
fs.createReadStream('object.json')
.setEncoding('utf8'),
new Transform({
decodeStrings: false, // Accept string input rather than Buffers
construct(callback) {
this.data = '';
callback();
},
transform(chunk, encoding, callback) {
this.data += chunk;
callback();
},
flush(callback) {
try {
// Make sure is valid json.
JSON.parse(this.data);
this.push(this.data);
callback();
} catch (err) {
callback(err);
}
}
}),
fs.createWriteStream('valid-object.json'),
(err) => {
if (err) {
console.error('failed', err);
} else {
console.log('completed');
}
}
);
双工流示例#
¥An example duplex stream
下面说明了一个 Duplex
流的简单示例,它封装了一个假设的更底层的源对象,数据可以写入到该源对象中,并且可以从中读取数据,尽管使用的 API 与 Node.js 流不兼容。下面说明了一个 Duplex
流的简单示例,它缓冲通过 Writable
接口传入的写入数据,这些数据通过 Readable
接口读回。
¥The following illustrates a simple example of a Duplex
stream that wraps a
hypothetical lower-level source object to which data can be written, and
from which data can be read, albeit using an API that is not compatible with
Node.js streams.
The following illustrates a simple example of a Duplex
stream that buffers
incoming written data via the Writable
interface that is read back out
via the Readable
interface.
const { Duplex } = require('node:stream');
const kSource = Symbol('source');
class MyDuplex extends Duplex {
constructor(source, options) {
super(options);
this[kSource] = source;
}
_write(chunk, encoding, callback) {
// The underlying source only deals with strings.
if (Buffer.isBuffer(chunk))
chunk = chunk.toString();
this[kSource].writeSomeData(chunk);
callback();
}
_read(size) {
this[kSource].fetchSomeData(size, (data, encoding) => {
this.push(Buffer.from(data, encoding));
});
}
}
Duplex
流最重要的方面是 Readable
和 Writable
端彼此独立运行,尽管它们共存于单个对象实例中。
¥The most important aspect of a Duplex
stream is that the Readable
and
Writable
sides operate independently of one another despite co-existing within
a single object instance.
对象模式双工流#
¥Object mode duplex streams
对于 Duplex
流,可以分别使用 readableObjectMode
和 writableObjectMode
选项为 Readable
或 Writable
端专门设置 objectMode
。
¥For Duplex
streams, objectMode
can be set exclusively for either the
Readable
or Writable
side using the readableObjectMode
and
writableObjectMode
options respectively.
例如,在下面的示例中,创建了一个新的 Transform
流(这是一种 Duplex
流),它具有对象模式 Writable
端,该端接受在 Readable
端转换为十六进制字符串的 JavaScript 数字。
¥In the following example, for instance, a new Transform
stream (which is a
type of Duplex
stream) is created that has an object mode Writable
side
that accepts JavaScript numbers that are converted to hexadecimal strings on
the Readable
side.
const { Transform } = require('node:stream');
// All Transform streams are also Duplex Streams.
const myTransform = new Transform({
writableObjectMode: true,
transform(chunk, encoding, callback) {
// Coerce the chunk to a number if necessary.
chunk |= 0;
// Transform the chunk into something else.
const data = chunk.toString(16);
// Push the data onto the readable queue.
callback(null, '0'.repeat(data.length % 2) + data);
}
});
myTransform.setEncoding('ascii');
myTransform.on('data', (chunk) => console.log(chunk));
myTransform.write(1);
// Prints: 01
myTransform.write(10);
// Prints: 0a
myTransform.write(100);
// Prints: 64
实现转换流#
¥Implementing a transform stream
Transform
流是 Duplex
流,其中输出以某种方式从输入计算得出。示例包括压缩、加密或解密数据的 zlib 流或 crypto 流。
¥A Transform
stream is a Duplex
stream where the output is computed
in some way from the input. Examples include zlib streams or crypto
streams that compress, encrypt, or decrypt data.
不要求输出与输入大小相同、块数相同或同时到达。例如,Hash
流将只有一个输出块,在输入结束时提供。zlib
流将产生比其输入小得多或大得多的输出。
¥There is no requirement that the output be the same size as the input, the same
number of chunks, or arrive at the same time. For example, a Hash
stream will
only ever have a single chunk of output which is provided when the input is
ended. A zlib
stream will produce output that is either much smaller or much
larger than its input.
stream.Transform
类被扩展以实现 Transform
流。
¥The stream.Transform
class is extended to implement a Transform
stream.
stream.Transform
类原型继承自 stream.Duplex
并实现其自己版本的 writable._write()
和 readable._read()
方法。自定义 Transform
实现必须实现 transform._transform()
方法,也可以实现 transform._flush()
方法。
¥The stream.Transform
class prototypically inherits from stream.Duplex
and
implements its own versions of the writable._write()
and
readable._read()
methods. Custom Transform
implementations must
implement the transform._transform()
method and may
also implement the transform._flush()
method.
使用 Transform
流时必须小心,因为如果 Readable
端的输出未被消耗,写入流的数据可能会导致流的 Writable
端暂停。
¥Care must be taken when using Transform
streams in that data written to the
stream can cause the Writable
side of the stream to become paused if the
output on the Readable
side is not consumed.
new stream.Transform([options])
#
-
options
<Object> 传给Writable
和Readable
构造函数。还有以下字段:¥
options
<Object> Passed to bothWritable
andReadable
constructors. Also has the following fields:-
transform
<Function>stream._transform()
方法的实现。¥
transform
<Function> Implementation for thestream._transform()
method. -
flush
<Function>stream._flush()
方法的实现。¥
flush
<Function> Implementation for thestream._flush()
method.
-
const { Transform } = require('node:stream');
class MyTransform extends Transform {
constructor(options) {
super(options);
// ...
}
}
或者,当使用 ES6 之前的样式构造函数时:
¥Or, when using pre-ES6 style constructors:
const { Transform } = require('node:stream');
const util = require('node:util');
function MyTransform(options) {
if (!(this instanceof MyTransform))
return new MyTransform(options);
Transform.call(this, options);
}
util.inherits(MyTransform, Transform);
或者,使用简化的构造函数方法:
¥Or, using the simplified constructor approach:
const { Transform } = require('node:stream');
const myTransform = new Transform({
transform(chunk, encoding, callback) {
// ...
}
});
事件:'end'
#
¥Event: 'end'
'end'
事件来自 stream.Readable
类。'end'
事件在所有数据输出后触发,发生在 transform._flush()
中的回调被调用之后。在出现错误的情况下,不应触发 'end'
。
¥The 'end'
event is from the stream.Readable
class. The 'end'
event is
emitted after all data has been output, which occurs after the callback in
transform._flush()
has been called. In the case of an error,
'end'
should not be emitted.
事件:'finish'
#
¥Event: 'finish'
'finish'
事件来自 stream.Writable
类。'finish'
事件在 stream.end()
被调用并且所有块都已被 stream._transform()
处理后触发。在出现错误的情况下,不应触发 'finish'
。
¥The 'finish'
event is from the stream.Writable
class. The 'finish'
event is emitted after stream.end()
is called and all chunks
have been processed by stream._transform()
. In the case
of an error, 'finish'
should not be emitted.
transform._flush(callback)
#
-
callback
<Function> 在刷新剩余数据时调用的回调函数(可选地带有错误参数和数据)。¥
callback
<Function> A callback function (optionally with an error argument and data) to be called when remaining data has been flushed.
此函数不得由应用代码直接调用。它应该由子类实现,并且只能由内部 Readable
类方法调用。
¥This function MUST NOT be called by application code directly. It should be
implemented by child classes, and called by the internal Readable
class
methods only.
在某些情况下,转换操作可能需要在流的末尾触发额外的数据位。例如,zlib
压缩流将存储一定数量的内部状态,用于优化压缩输出。但是,当流结束时,需要刷新额外的数据,以便压缩数据完整。
¥In some cases, a transform operation may need to emit an additional bit of
data at the end of the stream. For example, a zlib
compression stream will
store an amount of internal state used to optimally compress the output. When
the stream ends, however, that additional data needs to be flushed so that the
compressed data will be complete.
自定义 Transform
实现可以实现 transform._flush()
方法。当没有更多的写入数据可供使用时,但在 'end'
事件触发信号 Readable
流结束之前,将调用此方法。
¥Custom Transform
implementations may implement the transform._flush()
method. This will be called when there is no more written data to be consumed,
but before the 'end'
event is emitted signaling the end of the
Readable
stream.
在 transform._flush()
实现中,transform.push()
方法可能会被调用零次或多次,视情况而定。flush 操作完成后必须调用 callback
函数。
¥Within the transform._flush()
implementation, the transform.push()
method
may be called zero or more times, as appropriate. The callback
function must
be called when the flush operation is complete.
transform._flush()
方法带有下划线前缀,因为它是定义它的类的内部方法,不应由用户程序直接调用。
¥The transform._flush()
method is prefixed with an underscore because it is
internal to the class that defines it, and should never be called directly by
user programs.
transform._transform(chunk, encoding, callback)
#
-
chunk
<Buffer> | <string> | <any> 要转换的Buffer
,从string
转换为stream.write()
。如果流的decodeStrings
选项是false
或者流在对象模式下运行,则块将不会被转换并且将是传递给stream.write()
的任何内容。¥
chunk
<Buffer> | <string> | <any> TheBuffer
to be transformed, converted from thestring
passed tostream.write()
. If the stream'sdecodeStrings
option isfalse
or the stream is operating in object mode, the chunk will not be converted & will be whatever was passed tostream.write()
. -
encoding
<string> 如果块是字符串,则这是编码类型。如果 chunk 是缓冲区,那么这是特殊值'buffer'
。在这种情况下忽略它。¥
encoding
<string> If the chunk is a string, then this is the encoding type. If chunk is a buffer, then this is the special value'buffer'
. Ignore it in that case. -
callback
<Function> 在处理提供的chunk
后调用的回调函数(可选地带有错误参数和数据)。¥
callback
<Function> A callback function (optionally with an error argument and data) to be called after the suppliedchunk
has been processed.
此函数不得由应用代码直接调用。它应该由子类实现,并且只能由内部 Readable
类方法调用。
¥This function MUST NOT be called by application code directly. It should be
implemented by child classes, and called by the internal Readable
class
methods only.
所有 Transform
流实现都必须提供 _transform()
方法来接受输入和产生输出。transform._transform()
实现处理正在写入的字节,计算输出,然后使用 transform.push()
方法将该输出传递给可读部分。
¥All Transform
stream implementations must provide a _transform()
method to accept input and produce output. The transform._transform()
implementation handles the bytes being written, computes an output, then passes
that output off to the readable portion using the transform.push()
method.
transform.push()
方法可能被调用零次或多次以从单个输入块生成输出,具体取决于作为块的结果要输出多少。
¥The transform.push()
method may be called zero or more times to generate
output from a single input chunk, depending on how much is to be output
as a result of the chunk.
任何给定的输入数据块都可能不会生成任何输出。
¥It is possible that no output is generated from any given chunk of input data.
callback
函数只有在当前块被完全消耗时才必须被调用。如果在处理输入时发生错误,则传递给 callback
的第一个参数必须是 Error
对象,否则为 null
。如果第二个参数传递给 callback
,它将被转发给 transform.push()
方法。换句话说,以下是等价的:
¥The callback
function must be called only when the current chunk is completely
consumed. The first argument passed to the callback
must be an Error
object
if an error occurred while processing the input or null
otherwise. If a second
argument is passed to the callback
, it will be forwarded on to the
transform.push()
method. In other words, the following are equivalent:
transform.prototype._transform = function(data, encoding, callback) {
this.push(data);
callback();
};
transform.prototype._transform = function(data, encoding, callback) {
callback(null, data);
};
transform._transform()
方法带有下划线前缀,因为它是定义它的类的内部方法,不应由用户程序直接调用。
¥The transform._transform()
method is prefixed with an underscore because it
is internal to the class that defines it, and should never be called directly by
user programs.
transform._transform()
永远不会被并行调用;streams 实现了队列机制,要接收下一个块,必须同步或异步调用 callback
。
¥transform._transform()
is never called in parallel; streams implement a
queue mechanism, and to receive the next chunk, callback
must be
called, either synchronously or asynchronously.
类:stream.PassThrough
#
¥Class: stream.PassThrough
stream.PassThrough
类是 Transform
流的简单实现,它只是将输入字节传递到输出。它的目的主要是用于示例和测试,但在某些用例中,stream.PassThrough
可用作新型流的构建块。
¥The stream.PassThrough
class is a trivial implementation of a Transform
stream that simply passes the input bytes across to the output. Its purpose is
primarily for examples and testing, but there are some use cases where
stream.PassThrough
is useful as a building block for novel sorts of streams.
补充注意#
¥Additional notes
流与异步生成器和异步迭代器的兼容性#
¥Streams compatibility with async generators and async iterators
在 JavaScript 中异步生成器和迭代器的支持下,异步生成器在这一点上实际上是一流的语言级流构造。
¥With the support of async generators and iterators in JavaScript, async generators are effectively a first-class language-level stream construct at this point.
下面提供了将 Node.js 流与异步生成器和异步迭代器一起使用的一些常见互操作案例。
¥Some common interop cases of using Node.js streams with async generators and async iterators are provided below.
使用异步迭代器使用可读流#
¥Consuming readable streams with async iterators
(async function() {
for await (const chunk of readable) {
console.log(chunk);
}
})();
异步迭代器在流上注册一个永久错误处理程序,以防止任何未处理的销毁后错误。
¥Async iterators register a permanent error handler on the stream to prevent any unhandled post-destroy errors.
使用异步生成器创建可读流#
¥Creating readable streams with async generators
可以使用 Readable.from()
实用程序方法从异步生成器创建 Node.js 可读流:
¥A Node.js readable stream can be created from an asynchronous generator using
the Readable.from()
utility method:
const { Readable } = require('node:stream');
const ac = new AbortController();
const signal = ac.signal;
async function * generate() {
yield 'a';
await someLongRunningFn({ signal });
yield 'b';
yield 'c';
}
const readable = Readable.from(generate());
readable.on('close', () => {
ac.abort();
});
readable.on('data', (chunk) => {
console.log(chunk);
});
从异步迭代器管道传输到可写流#
¥Piping to writable streams from async iterators
从异步迭代器写入可写流时,确保正确处理背压和错误。stream.pipeline()
抽象了背压和背压相关错误的处理:
¥When writing to a writable stream from an async iterator, ensure correct
handling of backpressure and errors. stream.pipeline()
abstracts away
the handling of backpressure and backpressure-related errors:
const fs = require('node:fs');
const { pipeline } = require('node:stream');
const { pipeline: pipelinePromise } = require('node:stream/promises');
const writable = fs.createWriteStream('./file');
const ac = new AbortController();
const signal = ac.signal;
const iterator = createIterator({ signal });
// Callback Pattern
pipeline(iterator, writable, (err, value) => {
if (err) {
console.error(err);
} else {
console.log(value, 'value returned');
}
}).on('close', () => {
ac.abort();
});
// Promise Pattern
pipelinePromise(iterator, writable)
.then((value) => {
console.log(value, 'value returned');
})
.catch((err) => {
console.error(err);
ac.abort();
});
与旧 Node.js 版本的兼容性#
¥Compatibility with older Node.js versions
在 Node.js 0.10 之前,Readable
流接口更简单,但功能和用处也不大。
¥Prior to Node.js 0.10, the Readable
stream interface was simpler, but also
less powerful and less useful.
-
'data'
事件将立即开始触发,而不是等待对stream.read()
方法的调用。需要执行一些工作来决定如何处理数据的应用需要将读取的数据存储到缓冲区中,这样数据就不会丢失。¥Rather than waiting for calls to the
stream.read()
method,'data'
events would begin emitting immediately. Applications that would need to perform some amount of work to decide how to handle data were required to store read data into buffers so the data would not be lost. -
stream.pause()
方法是建议性的,而不是保证。这意味着即使流处于暂停状态,仍然需要准备接收'data'
事件。¥The
stream.pause()
method was advisory, rather than guaranteed. This meant that it was still necessary to be prepared to receive'data'
events even when the stream was in a paused state.
在 Node.js 0.10 中,添加了 Readable
类。为了与旧的 Node.js 程序向后兼容,当添加 'data'
事件处理程序或调用 stream.resume()
方法时,Readable
流切换到 "流动模式"。效果是,即使不使用新的 stream.read()
方法和 'readable'
事件,也不必再担心丢失 'data'
块。
¥In Node.js 0.10, the Readable
class was added. For backward
compatibility with older Node.js programs, Readable
streams switch into
"flowing mode" when a 'data'
event handler is added, or when the
stream.resume()
method is called. The effect is that, even
when not using the new stream.read()
method and
'readable'
event, it is no longer necessary to worry about losing
'data'
chunks.
虽然大多数应用将继续正常运行,但这会在以下情况下引入边缘情况:
¥While most applications will continue to function normally, this introduces an edge case in the following conditions:
-
没有添加
'data'
事件监听器。¥No
'data'
event listener is added. -
永远不会调用
stream.resume()
方法。¥The
stream.resume()
method is never called. -
流不会通过管道传输到任何可写目标。
¥The stream is not piped to any writable destination.
例如,考虑以下代码:
¥For example, consider the following code:
// WARNING! BROKEN!
net.createServer((socket) => {
// We add an 'end' listener, but never consume the data.
socket.on('end', () => {
// It will never get here.
socket.end('The message was received but was not processed.\n');
});
}).listen(1337);
在 Node.js 0.10 之前,传入的消息数据将被简单地丢弃。但是,在 Node.js 0.10 及更高版本中,套接字将永远保持暂停状态。
¥Prior to Node.js 0.10, the incoming message data would be simply discarded. However, in Node.js 0.10 and beyond, the socket remains paused forever.
这种情况下的解决方法是调用 stream.resume()
方法开始数据流:
¥The workaround in this situation is to call the
stream.resume()
method to begin the flow of data:
// Workaround.
net.createServer((socket) => {
socket.on('end', () => {
socket.end('The message was received but was not processed.\n');
});
// Start the flow of data, discarding it.
socket.resume();
}).listen(1337);
除了新的 Readable
流切换到流动模式之外,还可以使用 readable.wrap()
方法将 0.10 之前的样式流封装在 Readable
类中。
¥In addition to new Readable
streams switching into flowing mode,
pre-0.10 style streams can be wrapped in a Readable
class using the
readable.wrap()
method.
readable.read(0)
#
在某些情况下,需要触发底层可读流机制的刷新,而不实际消耗任何数据。在这种情况下,可以调用 readable.read(0)
,它总是返回 null
。
¥There are some cases where it is necessary to trigger a refresh of the
underlying readable stream mechanisms, without actually consuming any
data. In such cases, it is possible to call readable.read(0)
, which will
always return null
.
如果内部读取缓冲区低于 highWaterMark
,并且当前未读取流,则调用 stream.read(0)
将触发底层的 stream._read()
调用。
¥If the internal read buffer is below the highWaterMark
, and the
stream is not currently reading, then calling stream.read(0)
will trigger
a low-level stream._read()
call.
虽然大多数应用几乎不需要这样做,但在 Node.js 中有一些情况需要这样做,特别是在 Readable
流类内部。
¥While most applications will almost never need to do this, there are
situations within Node.js where this is done, particularly in the
Readable
stream class internals.
readable.push('')
#
不推荐使用 readable.push('')
。
¥Use of readable.push('')
is not recommended.
将零字节字符串、Buffer
或 Uint8Array
推送到非对象模式的流会产生有趣的副作用。因为是对 readable.push()
的调用,调用会结束读取过程。然而,因为参数是一个空字符串,所以没有数据被添加到可读缓冲区,所以用户没有任何东西可以使用。
¥Pushing a zero-byte string, Buffer
, or Uint8Array
to a stream that is not in
object mode has an interesting side effect. Because it is a call to
readable.push()
, the call will end the reading process.
However, because the argument is an empty string, no data is added to the
readable buffer so there is nothing for a user to consume.
调用 readable.setEncoding()
后 highWaterMark
不一致#
¥highWaterMark
discrepancy after calling readable.setEncoding()
使用 readable.setEncoding()
将改变 highWaterMark
在非对象模式下的运行方式。
¥The use of readable.setEncoding()
will change the behavior of how the
highWaterMark
operates in non-object mode.
通常,当前缓冲区的大小是根据 highWaterMark
以字节为单位测量的。但是,在调用 setEncoding()
之后,比较函数将开始测量缓冲区的字符大小。
¥Typically, the size of the current buffer is measured against the
highWaterMark
in bytes. However, after setEncoding()
is called, the
comparison function will begin to measure the buffer's size in characters.
在 latin1
或 ascii
的常见情况下,这不是问题。但建议在处理可能包含多字节字符的字符串时注意这种行为。
¥This is not a problem in common cases with latin1
or ascii
. But it is
advised to be mindful about this behavior when working with strings that could
contain multi-byte characters.