Node学习三、全局变量Buffer

Buffer 一般称之为 Buffer 缓冲区。

Buffer 让 Javascript 可以操作二进制。

Javascript 语言起初服务于浏览器平台&＃xff0c;因此它内部主要操作的数据类型就是字符串。

Nodejs 的出现使得可以在服务端使用 Javascript 进行编程&＃xff0c;完成 IO 操作&＃xff0c;例如文件的读写、网络服务中数据的传输等&＃xff0c;在这个过程中就是用到了 Buffer。

二进制数据

用户使用软件获取信息&＃xff0c;开发者使用语言处理和展示信息&＃xff0c;这个“信息”其实就是数据&＃xff0c;例如在客户端上看到的字符、视频、图片、音频等。

无论我们当前看到的是什么&＃xff0c;对于计算机来说&＃xff0c;它处理的都是数字&＃xff0c;也就是二进制。

IO 行为操作的就是二进制数据。

流操作

Stream 流操作并非 Nodejs 独创&＃xff0c;它本身已经存在很多年了。

可以将**“流”**理解为和字符串、数组类似的数据类型&＃xff0c;用于存储数据&＃xff0c;区别是它可以分段。

当进行大数据传输的时候就可以使用流操作&＃xff0c;这样可以避免由于操作的数据内存过大。而出现的将内存占满的情况。

流操作配合管道技术&＃xff0c;就可以将流当中的数据分段传输给下一个端&＃xff0c;实现大数据的传输。

典型的应用场景就是现在我们看视频一般都是边下载边看。

Buffer

程序运行就会进行二进制的数据传输&＃xff0c;而这个传输一般都是由 from 到 to 的过程&＃xff0c;即数据的生产者和数据的消费者&＃xff0c;中间就会使用流配合管道进行连接。

但是这个模型在实际工作的时候也会出现问题&＃xff0c;比如数据的生产速度无法满足数据的消费速度&＃xff0c;又或者数据的消费速度比生产速度慢了许多。

总归来说&＃xff0c;不论出现哪种情况&＃xff0c;数据都会有一个等待的过程&＃xff0c;等待的时候那些多出来的数据&＃xff0c;或者还不够一次消费的数据被存放在哪里呢&＃xff1f;

这个时候就有了 Buffer&＃xff0c;所以也称为 Buffer 缓冲区。

Nodejs 中 Buffer 就是一片内存空间&＃xff0c;只不过这个内存空间有些特殊。

Nodejs 中的代码最终都是由 V8 引擎执行完成的&＃xff0c;因此理论上所有的内存消耗应该都属于 V8 的堆内存&＃xff0c;而 Buffer 是 V8 之外的一片空间&＃xff0c;它的大小不占据 V8 堆内存的大小。

通过 process.memoryUsage() 获取的内存消耗的信息中有一个 arrayBuffers&＃xff0c;指的就是 Buffer 申请的内存。

Buffer 的空间申请不是由 Node 完成的&＃xff0c;但是在使用层面上&＃xff0c;它的空间分配又是由开发者编写的 JS 代码控制的&＃xff0c;因此在空间回收的时候&＃xff0c;它还是由 V8 的 GC&＃xff08;垃圾回收&＃xff09; 管理和回收&＃xff0c;开发者无法参与其中。

Buffer 总结

• Buffer 是 Nodejs 中的全局变量&＃xff0c;无需 require
• Buffer 使得可以在 Nodejs 平台下的操作二进制数据
• Buffer 本身是一片内存空间&＃xff0c;但是它不占据 V8 的堆内存大小&＃xff0c;直接由 C&＃43;&＃43; 层面进行分配
• Buffer 内存的使用由 Node 控制&＃xff0c;由 V8 的 GC 回收&＃xff0c;无法进行人为参与
• Buffer 一般配合 Stream 流使用&＃xff0c;充当数据缓冲区

Buffer 是 Nodejs 内置的类&＃xff0c;它相关的 API 其实就是这个类的静态方法。

有三种创建 Buffer 实例的方法&＃xff1a;

• Buffer.alloc(size[, fill[, encoding]])&＃xff1a;创建默认填充0的指定字节大小的 buffer
• Buffer.allocUnsafe(size)&＃xff1a;创建指定字节大小的 buffer&＃xff08;不安全的创建方法&＃xff09;&＃xff0c;不会向创建的内存填充数据
• Buffer.from(...)&＃xff1a;接收数据&＃xff0c;创建 buffer&＃xff08;与前两者的区别是创建默认带数据的 buffer&＃xff09;

为什么 allocUnsafe 不安全&＃xff1f;

关键在于给 Buffer 申请分配的内存是否被初始化。被初始化的内存即填充了默认的数据&＃xff0c;例如 0。没被初始化的内存可能包含敏感的旧数据&＃xff0c;这是不安全的。

Buffer.alloc() 分配的内存是初始化过的内存&＃xff08;被 0 填满覆写&＃xff09;&＃xff0c;这种创建方式虽然慢但被认为是安全的。

Buffer.allocUnsafe() 分配的内存没有被初始化&＃xff0c;所以分配速度相当快&＃xff0c;但内存中可能存在敏感旧数据&＃xff0c;在 Buffer 可读的情况下&＃xff0c;可能会泄露数据&＃xff0c;这种方式被认为是不安全的。一般会建议手动通过 buf.fill(0) 初始化或写满这个 Buffer。

虽然在使用 Buffer.allocUnsafe() 时有明显的性能优势&＃xff0c;但必须额外小心&＃xff0c;以避免给应用程序引入安全漏洞。

参考&＃xff1a;Buffer(Buffer) - Buffer.from(), Buffer.alloc(), and Buffer.allocUnsafe()

为什么不使用 new 创建 Buffer&＃xff1f;

在 Nodejs 的 v6 版本之前可以直接通过 new 实例化 Buffer 对象。

但是这种方式提供给 Buffer 实例对象的操作权限实在是太大了&＃xff0c;所以在后续的版本中对它进行了一些处理。

主要还是使用这种方式分配的内存是没有初始化过的&＃xff0c;包含敏感数据&＃xff0c;Node.js 认为在分配内存的安全性上需要更加明确的区分&＃xff0c;所以建议使用 Buffer 类的静态方法创建&＃xff0c;而不是通过 new 实例化。

// 创建空间大小是 10 字节的 buffer
// buffer 会以16进制格式存储每个字节的数据
const b1 &＃61; Buffer.alloc(10)
const b2 &＃61; Buffer.allocUnsafe(10)
console.log(b1) //
console.log(b2)// from 的第一个参数可以接收3种数据类型&＃xff1a;字符串 数组 buffer
const b3 &＃61; Buffer.from(&＃39;中&＃39;) // utf8 一个汉字用3个字节表示
console.log(b3) //
console.log(b3.toString()) // 中// from 的第一个参数如果是数组&＃xff0c;数组元素应该都是数字格式&＃xff08;十进制、八进制或十六进制等&＃xff09;&＃xff0c;否则会被忽略
const b4 &＃61; Buffer.from([1, 2, &＃39;中&＃39;]) // 汉字会被忽略
const b5 &＃61; Buffer.from([228/* 0xe4 的十进制 */, 0270/* 0xb8 的八进制 */, 0xad]) // 将汉字替换成数字
console.log(b4) //
console.log(b5) // // from 的第一个参数如果是 buffer&＃xff0c;创建的 buffer 只是传入的 buffer 的拷贝&＃xff0c;并不会共享空间
const b6 &＃61; Buffer.alloc(3)
const b7 &＃61; Buffer.from(b6)
b6[0] &＃61; 1
console.log(b6)
console.log(b7)
Buffer 实例方法

常用实例方法&＃xff1a;

• fill&＃xff1a;向 buffer 中反复填充数据&＃xff0c;直到填满&＃xff0c;返回填充后的 buffer
• write&＃xff1a;向 buffer 中写入数据&＃xff0c;返回写入的字节数
• toString&＃xff1a;根据指定的字符编码将 buffer 解码为字符串
• slice&＃xff1a;截取 buffer&＃xff0c;类似数组的 slice
• indexOf&＃xff1a;类似数组的 indexOf
• copy&＃xff1a;从 buffer 数据源拷贝数据到目标 buffer 中

// 创建一个空的 buffer
const buf &＃61; Buffer.alloc(6)// fill
buf.fill(&＃39;123&＃39;) // 反复填充直到填满
console.log(buf) //
console.log(buf.toString()) // 123123
buf.fill(&＃39;123456789&＃39;)
console.log(buf.toString()) // 123456
buf.fill(&＃39;0&＃39;).fill(&＃39;123&＃39;, 1) // 第二个参数表示跳过填充的字节数
console.log(buf.toString()) // 012312
buf.fill(&＃39;0&＃39;).fill(&＃39;123&＃39;, 1, 3) // 第三个参数表示停止填充的位置索引&＃xff08;指定位置也不填充&＃xff09;
console.log(buf.toString()) // 012000
buf.fill(123) // 如果填充的是数字&＃xff0c;则转化成十六进制填充
console.log(buf) //
console.log(buf.toString()) // {{{{{{


// 创建一个空的 buffer
const buf &＃61; Buffer.alloc(6)// write
// 与 fill 类似&＃xff0c;但只会写入一次
buf.write(&＃39;123&＃39;)
console.log(buf) //
console.log(buf.toString()) // 123buf.fill(0).write(&＃39;123&＃39;, 1)
console.log(buf) // buf.fill(0).write(&＃39;123&＃39;, 1, 2) // 第三个参数是写入的字节数
console.log(buf) //

// 创建一个空的 buffer
const buf &＃61; Buffer.from(&＃39;abc你好&＃39;)// toString
// 第一个参数是解码的字符编码
// 第二个参数表示开始解码的字节索引位置
// 第三个参数表示停止解码的字节索引位置&＃xff08;不被解码&＃xff09;
console.log(buf) //
console.log(buf.toString()) // abc你好
console.log(buf.toString(&＃39;utf8&＃39;, 1, 6)) // bc你// slice
const b1 &＃61; buf.slice(1, 6)
console.log(b1) //
console.log(b1.toString()) // bc你// indexOf
// 返回 Buffer 中指定字符的字节位置索引
// 第二个参数时查找开始的位置
const b2 &＃61; Buffer.from(&＃39;a你b好a你b好&＃39;)
console.log(b2.indexOf(&＃39;你&＃39;)) // 1
console.log(b2.indexOf(&＃39;b&＃39;)) // 4
console.log(b2.toString().indexOf(&＃39;b&＃39;)) // 2
console.log(b2.indexOf(&＃39;b&＃39;, 5)) // 12

// copy
// buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
// buf&＃xff1a;复制的数据源 buffer
// target&＃xff1a;目标 buffer
// targetStart&＃xff1a;写入目标 buffer 的起始字节位置
// sourceStart&＃xff1a;复制数据源 buffer 的起始字节位置
// sourceEnd&＃xff1a;复制数据源 buffer 的结束字节位置&＃xff08;不包含&＃xff09;
// 复制的内容到指定 sourceEnd 或填充完目标 buffer 即结束const b1 &＃61; Buffer.from(&＃39;你好abcde&＃39;)
const b2 &＃61; Buffer.alloc(6)b1.copy(b2)
console.log(b1) //
console.log(b1.toString()) // 你好abcde
console.log(b2) //
console.log(b2.toString()) // 你好const b3 &＃61; Buffer.alloc(6)
b1.copy(b3, 2, 3, 7)
console.log(b3) //
console.log(b3.toString()) // 好
Buffer 静态方法

常用静态方法&＃xff1a;

• concat&＃xff1a;将多个 buffer &＃xff08;数组&＃xff09;拼接成一个新的 buffer&＃xff0c;便于获取多个 buffer 组成的数据
• isBuffer&＃xff1a;判断当前数据是否是 Buffer 类型

// concat
// 第一个参数是要拼接的 buffer 组成的数组
// 第二个参数是要限制的拼接结果的长度
const b1 &＃61; Buffer.from(&＃39;你好&＃39;)
const b2 &＃61; Buffer.from(&＃39;世界&＃39;)const b3 &＃61; Buffer.concat([b1, b2])
console.log(b3.toString()) // 你好世界const b4 &＃61; Buffer.concat([b1, b2], 9)
console.log(b4.toString()) // 你好世// isBuffer
console.log(Buffer.isBuffer([])) // false
console.log(Buffer.isBuffer(&＃39;123&＃39;)) // false
console.log(Buffer.isBuffer(b1)) // true
自定义 Buffer 的 split

Buffer 在使用上有很多地方和数组类似&＃xff0c;例如下标操作、length 属性&＃xff08;Buffer 长度是固定的&＃xff0c;无法修改&＃xff09;等。

不过目前并没有对 Buffer 提供拆分&＃xff08;split&＃xff09;操作&＃xff0c;而这个操作在业务中又非常常见&＃xff0c;所以这里利用 Buffer 本身提供的原生方法自定义一个 split 方法。

// 自定义 butter-split
Buffer.prototype.split &＃61; function (separator) {const len &＃61; Buffer.from(separator).length // 获取分割符字节数let res &＃61; [] // 最终返回结果let start &＃61; 0 // 查询起始位置let offset &＃61; 0 // 偏移量while ((offset &＃61; this.indexOf(separator, start)) !&＃61;&＃61; -1) {res.push(this.slice(start, offset))start &＃61; offset &＃43; len}// 追加尾部res.push(this.slice(start))return res
}const buf &＃61; Buffer.from(&＃39;夫战&＃xff0c;勇气也&＃xff0c;一鼓作气&＃xff0c;再而衰&＃xff0c;三而竭&＃xff0c;彼竭我盈&＃xff0c;顾克之&＃xff0c;&＃39;)console.log(buf.split(&＃39;&＃xff0c;&＃39;).map(v &＃61;> v.toString()))