关于javascript:您不了解的缓冲区流

计算机是以二进制模式存储和示意数据，二进制是 0 和 1 的汇合。例如：0100，1010。比方，要存储数字 13 计算机须要将数字转换为 1101。

二进制中的 0 和 1 被称为位（bit）。只管它们很像示意一个数值，然而其实它们示意是符号。0 代表 FALSE, 1代表 TRUE。位的运算其实是对虚实值的操作。为了存储数据，计算机蕴含了大量的电路，每一个电路能存储独自的一个位。这种位存储器，被称为 ”主存储器 “。计算机通过 存储单元 组织治理 主存储器。一个典型的存储单元容量是 8 位，一个 8 位的串称为一个字节（byte）。

然而，数字不是咱们惟一须要存储解决的数据，咱们还须要解决字符串，图片，视频。

以字符串为例，那么计算机怎么存储字符串呢？例如，咱们要存储字符串 “S”，计算机首先会将 “S”, 转换为数字'S'.charCodeAt() === 83, 那么计算机是如何晓得 83 示意 ”S” 的？

字符集是曾经定义好的规定，每一个字符都有一个确切的数字示意。字符集有不同规定的定义，例如：”Unicode”, “ASCII”。浏览器中应用 ”Unicode” 字符集。正是 ”Unicode” 字符集，定义了 83 示意 ”S”。

那么接下来，计算机会间接将 83 转为二进制吗？并不是，咱们还须要应用 ” 字符编码 ”。

字符集定义了应用特定的数字示意字符（汉字也是同样的）。而字符编码定义了，如何将数字转换为特定长度的二进制数据。常见的 utf- 8 字符编码，规定了字符最多由 4 个字节进行编码（一个字节由 8 个，0 或者 1 示意）。

h e l l o <==Unicode==> 104 101 108 108 111 <==utf-8==> 1101000 1100101 1101100 1101100 1101111

对于视频，音频，图片，计算机也有特定规定，将其转换为二进制数据。计算机将所有数据类型，存储为二进制文件。这些二进制文件就是二进制数据。

数据流指数据从一个地位到另一个地位的挪动（通常大文件会被拆解为块的模式）。

如果数据流动的速度，大于过程解决数据的速度，多余的数据会在某个中央期待。如果数据流动的速度，小于过程解决数据的速度，那么数据会在某个中央累计到肯定的数量，而后在由过程进行解决。（咱们无法控制流的速度）

那个期待数据，累计数据，而后产生进来的中央。就是 缓冲区。缓冲区通常位于电脑的 RAM（内存）中。

咱们能够把缓冲区设想成一个公交车站，较早达到车站的乘客的会期待公交车，当公交车以及装满来到后，剩下的乘客会期待下一班的公交车到来。那个期待公交车的中央，就是缓冲区。

举一个常见的缓冲区的例子，咱们在观看在线视频的时候，如果你的网速很快，缓冲区总是会被立刻填充，而后发送进来，而后立刻缓冲下一段视频。观看的过程中，不会有卡顿。如果网速很慢，则会看到 loading，示意缓冲区正在被填充，当填充实现后数据被发送进来，能力看到这段视频。

在 TypedArray 呈现前，js 没有读取或操作二进制数据流的机制。TypedArray并不是一个特定的全局对象，而是许多全局对象的统称。

// TypedArray 指的是上面其中之一
Int8Array // 8 位二进制补码有符号整数的数组
Uint8Array // 8 位无符号整型数组（0 > & < 256(8 位无符号整形)），等等
Uint8ClampedArray
Int16Array
Uint16Array
Int32Array
Uint32Array
Float32Array
Float64Array

Buffer 类，是以 Nodejs 形式实现的 Uint8ArrayAPI（Uint8Array 属于 TypedArray 的一种）。用于与八字节的二进制数据进行交互。

Buffer.from, 承受多种形式的参数，上面介绍几种常见的

应用 8 字节的数组，作为参数

const buf = Buffer.from([0b1101000, 0b1100101, 0b1101100, 0b1101100, 0b1101111])
// hello
console.log(buf.toString())

应用字符串作为参数

const buf = Buffer.from('Hello World!');

// HelloWorld
console.log(buf.toString())

创立一个指定大小，并且曾经初始化的 Buffer（默认被 0 填充）

// 创立一个大小为 10 个字节的 Buffer，并应用 0 进行填充
const buf = Buffer.alloc(10)
// <Buffer 00 00 00 00 00 00 00 00 00 00>
console.log(buf)

// 创立一个大小为 12 个字节的 Buffer，并应用汉字进行填充
const buf = Buffer.alloc(12, '大')
// 打印出 大大大大，因为汉字是 3 个字节的关系，所以填充了 4 个汉字
console.log(buf.toString())

创立一个指定大小，然而没有初始化填充的 Buffer

// 创立一个大小为 10 个字节的 Buffer，没有被初始化
const buf = Buffer.allocUnsafe(10)

为什么说 Buffer.allocUnsafe 是不平安的？Buffer 是内存的形象，尝试运行console.log(Buffer.allocUnsafe(10000).toString()), 咱们应该能够从控制台看到打印出了内存里的一些货色

向 Buffer 中写入字符串，如果 Buffer 空间不够，多余的字符串不会被写入

const buf = Buffer.alloc(5)
// 您好的长度是 6 个字节
buf.write('您好')
// 您
console.log(buf.toString())

将 buffer 中的数据转换为 Unicode 码

const buf = Buffer.from('hello')

// {
//     type: 'Buffer',
//     data: [104, 101, 108, 108, 111] h e l l o 的 Unicode 码
// }
console.log(buf.toJSON())

将 buffer 解码成字符串


const buf = Buffer.from([0b1101000, 0b1100101, 0b1101100, 0b1101100, 0b1101111])
// hello
console.log(buf.toString())

思考上面这种状况，因为两个汉字的字节长度是 6，所以字节长度等于 5 的 buffer 是放不下的，所以打印进去的字符串是不残缺的。

const buf = Buffer.alloc(5, '您好')
// 您�
console.log(buf.toString())

那么有什么方法能够将 Buffer 中不残缺的字符串输入进去呢？咱们能够应用String Decoder

const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

// Buffer.from('好') <Buffer e5 a5 bd>
const str1 = decoder.write(Buffer.alloc(5, '您好'))
// 您
console.log(str1)
const str2 = decoder.end(Buffer.from([0xbd]))
// 好
console.log(str2)

StringDecoder 的实例承受写入 Buffer 的实例，应用外部缓冲区确保解码的字符串不蕴含不实现的字节，并且将不残缺的字节，保存起来，直到下一次应用 write 或者 end。

返回已解码的字符串，字符串不蕴含不残缺的字节，不残缺的字节。不残缺的字节会保留到 decoder 外部的缓冲区中。

const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

// 哈喽 <Buffer e5 93 88 e5 96 bd>
const str = decoder.write(Buffer.from([0xe5, 0x93, 0x88, 0xe5, 0x96]))
// 哈，0xe5, 0x96 因为不残缺不会被返回，而是保留在 decoder 的外部缓冲区
console.log(str)

会将 decoder 外部缓存区残余的 buffer 一次性返回。


const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

// 哈喽 <Buffer e5 93 88 e5 96 bd>
decoder.write(Buffer.from([0xe5, 0x93, 0x88, 0xe5, 0x96]))
const str = decoder.end()
// �，decoder 外部缓冲区残余的字节是不残缺的
console.log(str)

流是数据的汇合，流不像字符串或者数组一样是立刻可用的，流不会全副存在内存中。解决大量数据时，流十分有用。

Nodejs 中，许多模块都实现了流模式。下图是实现了流模式的内置模块(图片来自于 Samer Buna 的在线课程)

Writable，可写入流，是写入指标的形象，常见的例子：fs.createWriteStream
Readable，可读取流，是数据源的形象。常见的例子：fs.createReadStream
Duplex，可读可写流（双工流）
Transform，也是一种可读可写流，然而能够读取写入的时候批改转换数据。所以也能够叫做转换流。例如：zlib.createGzip压缩数据流

const fs = require('fs')
// 可读流作为数据源
const readable = fs.createReadStream('./ 数据源.json')
// 可写流作为指标
const writable = fs.createWriteStream('./ 指标.json')
// 将数据源通过管道连贯到指标
readable.pipe(writable)

在这几行简略的代码中咱们将可读流的输入（readable作为数据源），连贯管道至可写流的输出（writable作为指标）。源必须是可读流，指标必须是可写流。

const fs = require('fs')
const zlib = require('zlib')

const readable = fs.createReadStream('./ 数据源.json')
// gzip 是一个双工流
const gzip = zlib.createGzip()
const writable = fs.createWriteStream('./ 指标.gz')

// 数据源连贯到转换流（gzip），转换流解决数据后，连贯到指标上
readable
    .pipe(gzip)
    .pipe(writable)

咱们也能够将可读流的管道连贯到双工流（转换流）上。总结一下 pipe 办法的用法。pipe能够返回一个指标流，指标流能够连贯到双工流，可写流上。

可读流
    .pipe(双工流)
    .pipe(双工流)
    .pipe(可写流)

应用 pipe 是生产流最简略的办法，它会主动治理一些操作，比方错误处理，比方如果可读流没有数据可供生产时的状况。当然咱们也能够通过事件生产流，然而最好防止两者混合应用。

如果须要对流实现，更自定义的管制，能够应用事件生产流。上面的这段代码和之前的 pipe 的代码是等效的。

const fs = require('fs')

const readable = fs.createReadStream('./ 数据源.json')
const writable = fs.createWriteStream('./ 指标.json')

// 当可读流绑定 data 事件时，会将流切换到流动模式
readable.on('data', (chunk) => {writable.write(chunk);
})

readable.on('end', () => {writable.end()
})

下图是可读流，可写流的事件与办法的列表(图片来自于 Samer Buna 的在线课程)

下面对于流事件的示例中，是存在隐患的。具体的问题起因，能够查看我的这篇文章简略了解 backpressure（背压）机制


// 其实这段代码是其实有问题的
readable.on('data', (chunk) => {writable.write(chunk);
})

默认状况下，可读流是处于暂停状态的，然而它们能够被切换到流动模式，并在须要时切换回暂停模式。有时，模式会被主动产生切换。

在暂停模式时，咱们能够应用 read 办法从流中读取数据。

const fs = require('fs')

const readable = fs.createReadStream('./ 数据源.json')
const writable = fs.createWriteStream('./ 指标.json')
// 当可读流是能够被读取时或者会发生变化时或者达到流的止境时。readable 能够被触发
readable.on('readable', () => {
    let chunk
    while (chunk = readable.read(1)) {writable.write(chunk)
    }
})

在流动模式时，数据会继续流动，咱们必须增加事件并生产它。如果不能解决流动的数据，数据是会失落的。咱们能够增加 data 事件处理数据。增加 data 事件，会主动将可读流的模式，由暂停模式切换到流动模式。

如果须要实现两种模式的手动切换能够应用 resume()（从暂停模式中复原）和pause()（进入暂停模式）办法。（如果监听了可读流的readable 的事件，resume()办法有效）

上面的例子中，每一次通过可写流写入一点数据，都会暂停一秒可读流 1s，1s 后持续写入。

const fs = require('fs')

const readable = fs.createReadStream('./ 数据源.json')
const writable = fs.createWriteStream('./ 指标.json')

// 主动切换到流动模式
readable.on('data', (chunk) => {console.log('写入')
    writable.write(chunk)
    readable.pause()
    console.log('暂停')
    // 暂停 1s 后，从新切换到流动模式
    setTimeout(() => {readable.resume()
    }, 1000)
})

下图是两种模式之前的切换 (图片来自于 Samer Buna 的在线课程)。增加data 事件时（独自增加 data 事件，不存在 readable 事件时），模式会主动切换。

创立一个自定义的可写流，咱们须要继承 stream.Writable 类。并在子类中实现 _write 办法。


const {Writable} = require('stream')

class CustomWritable extends Writable {
    /**
     * @param chunk 须要写入的数据
     * @param encoding 编码格局
     * @param next 解决实现的回调
     */
    _write(chunk, encoding, next) {
        try {
            // 仅仅是做了一个打印
            console.log(` 仅仅做了一个打印：${chunk.toString()}`)
            next()} catch (error) {next(error)
        }
    }
}

这个流自身没有多大的意义。这个自定义可写流，只会对可读流输出的数据，进行一个打印。咱们能够链接到 process.stdin 可读流上，对终端的输出，进行一个打印。


const customWritable = new CustomWritable()

process.stdin.pipe(customWritable)

创立一个可读流，咱们须要继承 stream.Readable 类。并在子类中实现 _read 办法。

const {Readable} = require('stream'); 

class CustomReadable extends Readable {_read () {}}

这个流自身也没有很大的意义。咱们能够应用 push 办法，将数据增加到流的外部队列中，以供流进行生产。咱们能够联合前一个自定义的可写流，将 push 的数据打印进去。


const customReadable = new CustomReadable()
const customWritable = new CustomWritable()

customReadable.push('我喜爱西尔莎罗南')
// 告诉流不会有任何数据了
customReadable.push(null)

// 可读流将数据传递给可写流
// 可写流将数据打印进去
customReadable.pipe(customWritable)

创立一个可读流，咱们须要继承 stream.Transform 类。并在子类中实现 _transform 办法。

const {Transform} = require('stream')

class CustomTransform extends Transform {_transform (chunk, encoding, next) {
        // 咱们把可读流的内容，全副转换为大写
        chunk = chunk.toString().toUpperCase()
        next(null, chunk)
    }
}

这个自定义流，会将可读流传过去的字符串，全副转换为大写。

const customReadable = new CustomReadable()
const customWritable = new CustomWritable()
const customTransform = new CustomTransform()

customReadable.push('abcdefg')
customReadable.push(null)

customReadable
    .pipe(customTransform)
    .pipe(customWritable)

Node 中的流，默认都是应用 Buffer 或者字符串进行传输，咱们能够开启 objectMode 开关。使流能够传输 js 的对象。


const {Readable, Writable} = require('stream')

class CustomReadable extends Readable {_read () {}}

class CustomWritable extends Writable {_write(chunk, _, next) {
        try {
            // 这里能够打印 js 对象
            // chunk 能够使 js 对象
            console.log(chunk)
            next()} catch (error) {next(error)
        }
    }
}

const customReadable = new CustomReadable({objectMode: true // 开启对象模式})
const customWritable = new CustomWritable({objectMode: true // 开启对象模式})

// 咱们能够传输对象了
customReadable.push(['a', 'b', 'c', 'd'])
customReadable.push(null)

customReadable.pipe(customWritable)

计算机科学概论(第 11 版)
✨Node.js Streams: Everything you need to know
✨Do you want a better understanding of Buffer in Node.js? Check this out
Node.js v13.8.0 Documentation

关于javascript:您不了解的缓冲区流

什么是二进制数据？

什么是字符集？

什么是字符编码？

什么是缓冲区？

Buffer 类

什么是 TypedArray？

什么是 Buffer 类？

常见的 API

Buffer.from

Buffer.alloc

Buffer.allocUnsafe

buffer.write

buffer.toJSON

buffer.toString

String Decoder

decoder.write

decoder.end

什么是流？

流的类型

流的管道

流的事件

对于下面的例子中存在的一些问题

流的可读流的暂停和流动模式

流的实现

创立自定义可写流

创立自定义可读流

创立自定义转换流

对象模式

参考