nodejs 简单介绍一下四种流（stream）的知识

前言

本文介绍nodejs关于流的一些简单内容，对于文件的读写等操作，掌握流的使用是必须的。

流的分类

---

流分为四类：可读流、可写流、双工流、转换流。

可读流、可写流很好理解，就分别是对文件进行读和写操作的流。

而双工流则是可读流和可写流组合成的对象，是既可以读又可以写的流。

最后转换流顾名思义，可以将写入的数据在同一个流中变成可读的，且通常是某种转换后的形式。（也是可读可写的）

可读流

---

1. fs.createReadStream('文件路径')就是一种可读流。
2. 例子中我们可以看到可读流可以监听几个事件，data事件是有数据在读取过程中的的事件，end是读取完毕时的事件，还有error事件可以进行错误监听，比如如果test.txt文件不存在则会报未找到对应文件的错误，还有一些其他事件我就不一一列出了。

import fs from 'fs'
const readStream = fs.createReadStream('test.txt')
let res = ''

readStream.on('data', (buffer) => {
    res += buffer 
})

readStream.on('end', () => {
    console.log(res) // test.txt文件中的内容
})

readStream.on('error', (err) => {
    console.log(err)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 流的事件是可以链式调用的，下面这样绑定事件运行结果和上面的代码是没有区别的。

import fs from 'fs'
const readStream = fs.createReadStream('test.txt')
let res = ''

readStream.on('data', (buffer) => {
    res += buffer
}).on('end', () => {
    console.log(res)  // test.txt文件中的内容
}).on('error', (err) => {
    console.log(err)
})
1
2
3
4
5
6
7
8
9
10
11

可写流

---

1. fs.createWriteStream('文件路径')就是一种可写流。
2. 配置flags可以修改写入模式。w表示写入数据，会覆盖原内容；a表示追加数据，会在原内容后面添加写入内容。另外还可以有w+与a+，添加+会进行读取操作，也就是先读取再写入与先读取再追加。
3. 可写流调用write方法即可对文件进行写入。
4. 可写流也有自己的一些可监听事件，常用的finish表示写入操作完成。

import fs from 'fs'

const writeStream = fs.createWriteStream('out.txt', {
    flags: 'w', 
})

writeStream.write('666')

writeStream.on('finish', () => {
    console.log('写入完成')
}).on('error', (err) => {
    console.log(err)
})
1
2
3
4
5
6
7
8
9
10
11
12
13

5. 可写流的write方法调用之后，会返回一个boolean值，当它为false时，则表示写入数据的速度超过了处理数据的速度，是一种背压的表现。
6. 遇到背压时，需要先停止继续调用write，等到可写流的drain监听事件发生则表示处理完毕，可以继续执行write。
7. 下方例子，当我们进行多次写入操作时，假设遇到会产生背压的长文本，会返回未解决的期约，同时监听drain事件，事件发生表示背压状态结束，解决期约，即可继续写入下一段文本。

function write(stream, chunk) {
    let hasMoreRoom = stream.write(chunk)
    if (hasMoreRoom) {
        return Promise.resolve(null)
    } else {
        return new Promise((resolve, reject) => {
            stream.once('drain', resolve)
        })
    }
}

async function test() {
    const writeStream = fs.createWriteStream('out.txt', {flags: 'a'})
    await write(writeStream, '很长的文本串')
    await write(writeStream, '很长的文本串')
    await write(writeStream, '很长的文本串')
}

test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

8. 当我们从一个可写流读取文件，再用可写流来写入文件时，遇到背压，我们可以通过调用可读流的pause方法暂停可读流来解决，等到可读流drain事件发生，再使用可读流的resume方法继续读取。

import fs from 'fs'

const readStream = fs.createReadStream('test.txt')
const writeStream = fs.createWriteStream('copy.txt', {
    flags: 'w'
})

readStream.on('data', (buffer) => {
    const hasMoreRoom = writeStream.write(buffer)
    if (!hasMoreRoom) {
        readStream.pause()
    }
})

writeStream.on("drain", () => {
    readStream.resume()
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

管道

前面介绍了可读流和可写流，假如我们想要复制一个文件该怎么做呢？

也就是要先读取文件，再写入到新文件。通过前面的知识，我们可以创建可读流获取数据，可写流开始写入：

import fs from 'fs'

const readStream = fs.createReadStream('test.txt')
const writeStream = fs.createWriteStream('copy.txt', {
    flags: 'w'
})

readStream.on('data', (buffer) => {
    writeStream.write(buffer)
})
1
2
3
4
5
6
7
8
9
10

我们想象一下，两个流之间，假如有一个管道能够将它们连接在一起，可读流到可写，就不需要我们手动进行一些操作了。

流之间就有一个pipe方法可以将流与流之间建立管道。

import fs from 'fs'

const readStream = fs.createReadStream('test.txt')
const writeStream = fs.createWriteStream('copy.txt', {
    flags: 'w'
})

readStream.pipe(writeStream) // 将可读流直接流入可写流，实现读取再写入的操作
1
2
3
4
5
6
7
8

同时也可以添加事件。

在管道前的链式调用事件对象是前面的流（即可读流），在管道之后，链式调用事件的对象就成了管道连接的后面的流了（即可读流）。

readStream.on('end', () => {
    console.log('读取完毕')
}).pipe(writeStream).on('finish', () => {
    console.log('写入完毕')
})
1
2
3
4
5

双工流

1. net.connect()和其他Node网络API返回的Socket对象就是双工流。
2. 比如某种流，其中有可写流用于向服务器发送消息，可读流用于接受服务器消息，这就是一种通过可读流可写流组合在一起形成的双工流。

转换流

1. zlib.createGzip()可以压缩文件数据，其就是一种转换流。
2. 可读流可以与它建立管道让它写入，可以证明它可写；它可以读取数据与可写流建立管道，可以证明它可读。由此可以得出，它就是可读可写的转换流。

import fs from 'fs'
import zlib from 'zlib'

const readStream = fs.createReadStream('test.txt')
const duplexStream = zlib.createGzip()
const writeStream = fs.createWriteStream('test.txt.gz', {
    flags: 'w'
})
readStream // 读
    .pipe(duplexStream) // 转换流压缩
    .pipe(writeStream)  // 写
1
2
3
4
5
6
7
8
9
10
11

尾言

本文介绍了流的一些简单内容，能够让你对流有一些基本概念，如果有任何错误或者建议，欢迎指出，我会及时修改。

如果文章对你有帮助的话，欢迎点赞收藏~