自定义Buffer方法

Buffer类，是用来创建一个专门存放二进制数据的缓存区。每当需要处理二进制数据时，就有可能使用到Buffer类。

1.Buffer的常用方法

1.1 Buffer.alloc()

用来声明一段固定大小的Buffer实例，如果没有设置fill，则默认填满0

let buffer = Buffer.alloc(6);
console.log(buffer);
//<Buffer 00 00 00 00 00 00>

1.2 Buffer.from()

let buffer = Buffer.from('前端优选');
console.log(buffer);
//<Buffer e5 89 8d e7 ab af e4 bc 98 e9 80 89>

该结果返回的是十六进制、UTF-8编码格式的字节

1.3 buffer.toString([encoding[,start[,end]]])

//接上个例子
console.log(newBuff.toString());
//前端

toString默认使用的编码是uft8，返回指定编码的字符串；该方法还可指定读取索引的起始结束位置

1.4 buffer.length

let buffer = Buffer.from('前端优选');
let length = buffer.length;
console.log(length);
//12

返回的是内存区长度；一个汉子包括三个字节，则结果就是4*3=12个字节长度

1.5 Buffer.isBuffer()

let buffer = Buffer.from('前端优选');
let result = Buffer.isBuffer(buffer);
//true

判断一个值是否为Buffer类型，返回的结果为布尔值

1.6 buffer.slice(start[,end])

let buffer = Buffer.from('前端优选');
let result = buffer.slice(6,12);
console.log(result.toString());
//优选

返回一个新的buffer值，和原有值指向同一个内存区

1.7 buffer.indexOf()

let buffer = Buffer.from('前端优选');
let index = buffer.indexOf('优选');
console.log(index);
//6

返回字符串的内存起始位置

1.8 Buffer.concat(list[,length])

let buffer1 = Buffer.from('前端');
let buffer2 = Buffer.from('优选');
let buffer3 = Buffer.concat([buffer1,buffer2]);
console.log(buffer3);
console.log(buffer3.toString());
//<Buffer e5 89 8d e7 ab af e4 bc 98 e9 80 89>
//前端优选

返回的值是多个成员合并的新Buffer对象

1.9 buffer.copy(target[,targetStart[,sourceStart[,sourceEnd]]])

指定要拷贝的目标，从目标起始位置开始，拷贝源buffer的指定起始和结束位置之间的字符
该方法没有返回值，直接对target进行操作

let buff1 = Buffer.from('前端');
let buff2 = Buffer.from('优选');
buff1.copy(buff2,0,0,3);
console.log(buff2.toString());
//前选(从buff2的0位置起始，拷贝buff1的0-3位置之间的字符，操作对象为buff2)

2.Buffer的特点

Buffer是引用的内存空间，换句话说就是引用类型的值，不管是截取或更改，都是对内存空间的修改，因此都会改变原有的值。

let buffer = Buffer.from([11,12,13]);
let newBuff = buffer.slice(0,3);
newBuff[0] = 100;
console.log(buffer);
//<Buffer 64 0c 0d>

3.Buffer自定义方法

3.1 split方法

let buffer = Buffer.from('前爱端爱优爱选');
let res = buffer.split('爱');
//期望输出结果：['前','端','优','选'];

那么需要自定义一个split方法

Buffer.prototype.split = function(step){
    let arr = [];
    return arr;
}

首先，需要得出分割字符串的长度

let len = Buffer.from(step).length;

其次，指定每次的分割起始位置

let offset = 0; //初次分割从0开始，然后依次累加

然后，记录当前分割位置，将已分割和分割字符的长度求和

let current = this.indexOf(step,offset);

对分割的起始位置进行更新

offset = current + len;

循环遍历，直到查询结束为止

while(-1 != this.indexOf(step,offset)){
    current = this.indexOf(step,offset);
    arr.push(this.slice(offset,current));
    offset = current + len;
}

最终方法为：

Buffer.prototype.split = function(step){
    let len = Buffer.from(step).length;
    let offset = 0;
    let current = 0;
    let arr = [];
    while(-1 != this.indexOf(step,offset)){
        current = this.indexOf(step,offset);
        arr.push(this.slice(offset,current));
        offset = current + len;
    }
    arr.push(this.slice(offset));   //将剩余结果进行添加
    return arr.map(item => item.toString());
}

3.2 手动实现Buffer的concat方法

首先看concat的使用方式

let buff1 = Buffer.from('前端');
let buff2 = Buffer.from('优选');
let buff3 = Buffer.concat([buff1,buff2]);
console.log(buff3.toString());
//前端优选

分析：该方法至少需要传递两个参数：用于合并的数组列表（必填）、指定合并后的总长度（可选）

Buffer.concat = function(list,length=list.reduce((a,b) => a+b.length,0){
    //通过对list的长度求和，计算指定长度
    let buffer = Buffer.alloc(length);
    let offset = 0;
    list.forEach(item => {
        item.copy(buffer,0);    //利用copy方法，依次复制
        offset += item.length;  //更新每次的复制指针
    })
    return buffer;
}

4.总结

Buffer存在于全局对象上，是必须要了解和掌握的知识。Buffer是在内存中开辟一片区域，用来存放二进制数据，在文件的读取和传输上，有着重要的作用。

原文：https://segmentfault.com/a/1190000021375884

链接: https://fly63.com/article/detial/7020