P04：nodeAPI 之 Buffer创建一个长度为 10、且未初始化的 Buffer。因此需要使用 fill()

缓冲器 Buffer

Buffer 类是作为 Node.js API 的一部分引入的，用于在 TCP 流、文件系统操作、以及其他上下文中与八位字节流进行交互
Buffer 是用来处理二进制数据流的
Buffer 实例类似于整数数组，但是其长度大小固定(创建后不可修改)
Buffer c++ 在V8堆外分配的物理内存
Buffer 是一个全局变量，直接挂载在global下

Buffer的常用静态属性和方法:

Buffer.alloc()

Buffer.alloc(10) 第一个参数为长度，不填内容（第二个参数），即用 0 填充
Buffer.alloc(10, 1) 第二参数为填充内容

console.log(Buffer.alloc(10)) // 创建一个长度为10的buffer
// 输出结果： <Buffer 00 00 00 00 00 00 00 00 00 00>
console.log(Buffer.alloc(10,1)) // 创建一个长度为10的buffer 并且使用1作为默认位的填充
// 输出结果： <Buffer 01 01 01 01 01 01 01 01 01 01>

Buffer.allocUnsafe()
- 创建一个长度为 10、且未初始化的 Buffer。
- 这个方法比调用 Buffer.alloc() 更快，
- 但返回的 Buffer 实例可能包含旧数据，
- 因此需要使用 fill() 或 write() 重写。
- 不常用
```
console.log(Buffer.allocUnsafe(10))
//  <Buffer 98 fe a5 8d fa 01 00 00 58 ff> 未经初始化的混乱Buffer
```
Buffer.from()
- Buffer.from([1,2,3]) 创建一个包含 [0x1, 0x2, 0x3] 的 Buffer。
- Buffer.from('test', 'latin1') 创建一个包含 Latin-1 字节 [0x74, 0xe9, 0x73, 0x74] 的 Buffer
```
console.log(Buffer.from([1,2,3]))
// <Buffer 01 02 03>
console.log(Buffer.from('test', 'latin1'))
// <Buffer 74 65 73 74>
```
Buffer.byteLength()
- 返回字符串的实际字节长度。与 String.prototype.length 不同，后者返回字符串的字符数
```
Buffer.byteLength('test') // 4 英文字母占位一个字节
Buffer.byteLength('测试') // 6 中文占位三个字节
```
Buffer.isBuffer(obj)
- obj 是一个 Buffer，则返回 true，否则返回 false。
```
Buffer.isBuffer({}) false
Buffer.isBuffer(Buffer.from([1,2,3])) true
```

Buffer.concat()

    // 用含有三个 `Buffer` 实例的数组创建一个单一的 `Buffer`。

    const buf1 = Buffer.alloc(10);
    const buf2 = Buffer.alloc(14);
    const buf3 = Buffer.alloc(18);
    const totalLength = buf1.length + buf2.length + buf3.length;

    console.log(totalLength);
    // 打印: 42
    // 如果已知长度，则明确提供长度会更快
    const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);

    console.log(bufA);
    // 打印: <Buffer 00 00 00 00 ...>
    console.log(bufA.length);
    // 打印: 42

buf.length
- 返回内存中分配给 buf 的字节数。不一定反映 buf 中可用数据的字节量。
```
const buf = Buffer.from('1212！')
buf.length
```
buf.toString([encoding[, start[, end]]])
- encoding 使用的字符编码。默认值: 'utf8'。
- start 开始解码的字节偏移量。默认值: 0。
- end 结束解码的字节偏移量（不包含）。默认值: buf.length。
- 返回:
- 根据 encoding 指定的字符编码将 buf 解码成字符串。传入 start 和 end 可以只解码 buf 的子集。
```
console.log(b.toString())
```
buf.fill()
- 修改buf值
- buf.fill(value[, offset[, end]][, encoding])
- value | | | 用来填充 buf 的值。
- offset 开始填充 buf 的偏移量。默认值: 0。
- end 结束填充 buf 的偏移量（不包含）。默认值: buf.length。
- encoding 如果 value 是字符串，则指定 value 的字符编码。默认值: 'utf8'。
- 返回: buf 的引用。
```
        const buf1 = Buffer.alloc(10)
        console.log(buf1.fill('e',2,5)) //<Buffer 00 00 65 65 65 00 00 00 00 00>
    ```
```

buf.equals(otherBuffer)

对比两个buf的值是否相同
otherBuffer 要与 bur 对比的 Buffer 或 Uint8Array。

    const buf1 = Buffer.from('ABC');
    const buf2 = Buffer.from('414243', 'hex');
    const buf3 = Buffer.from('ABCD');

    console.log(buf1.equals(buf2));
    // 打印: true
    console.log(buf1.equals(buf3));
    // 打印: false

buf.indexOf() 类似于数组的 Array.indexOf()
- 汉字占三个字符， ==> 解决可能出现的中文乱码问题

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])

target | 要拷贝进的 Buffer 或 Uint8Array。
targetStart target 中开始写入之前要跳过的字节数。默认值: 0。
sourceStart buf 中开始拷贝的偏移量。默认值: 0。
sourceEnd buf 中结束拷贝的偏移量（不包含）。默认值: buf.length。

返回: 拷贝的字节数。

    // 创建两个 `Buffer` 实例。
    const buf1 = Buffer.allocUnsafe(26);
    const buf2 = Buffer.allocUnsafe(26).fill('!');

    for (let i = 0; i < 26; i++) {
    // 97 是 'a' 的十进制 ASCII 值。
    buf1[i] = i + 97;
    }

    // 拷贝 `buf1` 中第 16 至 19 字节偏移量的数据到 `buf2` 第 8 字节偏移量开始。
    buf1.copy(buf2, 8, 16, 20);

    console.log(buf2.toString('ascii', 0, 25));
    // 打印: !!!!!!!!qrst!!!!!!!!!!!!!

    // 创建一个 `Buffer`，并拷贝同一 `Buffer` 中一个区域的数据到另一个重叠的区域。

    const buf = Buffer.allocUnsafe(26);

    for (let i = 0; i < 26; i++) {
    // 97 是 'a' 的十进制 ASCII 值。
    buf[i] = i + 97;
    }

    buf.copy(buf, 0, 4, 10);

    console.log(buf.toString());
    // 打印: efghijghijklmnopqrstuvwxyz

string_decoder

string_decoder 模块提供了一个 API，用于以保留编码的多字节 UTF-8 和 UTF-16 字符的方式将 Buffer 对象解码为字符串

    // 如何去除buffer中文乱码
    const buf = Buffer.from('中文乱码在此！')
    // string_decoder 是buffer的内置模块
    // 将 Buffer 实例写入 StringDecoder 实例时，将使用内部缓冲区来确保已解码的字符串不包含任何不完整的多字节字符。
    // 它们保存在缓冲区中，直到下一次调用 stringDecoder.write() 或调用 stringDecoder.end() 为止
    // 简单说就是会自动识别多字节字符，代码操作出现不完整的情况下不做输出，
    //而是存储在内存中，在下一次操作中拼接在起始位置
    const { StringDecoder } = require('string_decoder')
    const decoder = new StringDecoder('utf8')
    for(let  i = 0; i< buf.length; i+=5) {
        // 生成未初始化的Buffer
        const b = Buffer.allocUnsafe(5)
        // 拷贝
        buf.copy(b, 0, i)
        console.log(b.toString())
        // 结果
        // 中�
        // �乱�
        // ��在
        // 此�
        // ��4�║
    }
    for(let  i = 0; i< buf.length; i+=5) {
        // 生成未初始化的Buffer
        const b = Buffer.allocUnsafe(5)
        // 拷贝
        buf.copy(b, 0, i)
        console.log(decoder.write(b))
    }

close

P04：nodeAPI 之 Buffer

相关文章

缓冲器 Buffer

Buffer的常用静态属性和方法: