nodejs-Buffer

Buffer 作为一个全局变量，不需要使用require(‘buffer’).Buffer来引入；Buffer的作用就是用来处理二进制数据流，直接对内存进行操作；Buffer的大小一旦被确定就不能被修改

Buffer底层是arrayBuffer，(buf.buffer === arrayBuffer) is true，arrayBuffer又称类型化数组，其成员是0/1二进制数据，一旦初始化则固定大小，不再扩充或缩小；arrayBuffer将数据放在栈中，数组则放在堆中，arrayBuffer取数据更快

 nodejs 编码格式 支持 ascii, utf8, utf16le, ucs2, base64, latin1, binary, hex

Buffer模块初解，创建、写入和读取

创建并填充：Buffer.alloc(size[, fill[, encoding]])

创建不填充：Buffer.allocUnsafe(size)

创建包含字符串：Buffer.from(string[, encoding]

 

填充：buf.fill(value[, offset[, end]][, encoding]

读：buf.toString(); buf[index]; buf.slice(); buf.readUIbt8();

var cl = function(data){
    console.log(data);
}
var clstr = function(data){
    console.log(data.toString());
}


/** Buffer.alloc(size[, fill[, encoding]])
 * size : 创建缓存大小
 * fill : 默认填充/初始化 类型:string || Buffer || integer, 默认0
 * encoding : 编码 fill == string ,encoding = utf8
 * 
 * 如果制定了fill[, encoding],则会调用Buffer.fill(fill[, encoding])初始化分配的Buffer
 */
var falloc = ()=>{
    const buf1 = Buffer.alloc(10);   // 创建长度为10，默认用0填充的Buffer
    console.log(buf1);   // 16进制数的buffer流
    
    const buf2 = Buffer.alloc(10,1); //长度为10，用0x1填充的Buffer
    console.log(buf2);

    // 特殊测试
    var buf3 = Buffer.alloc(10,'thetest');
    clstr(buf3);                    // 'thetestthe'
    cl(buf3.length);
}
// falloc();


/** Buffer.allocUnsafe(size)
 * size : 创建缓存大小
 */
var fallocUn = ()=>{
    var buf4 = Buffer.allocUnsafe(10);// 不带有初始化功能，更快
    buf4.fill(0);    //初始填充
    console.log(buf4);
}
// fallocUn();


/** Buffer.from(string[, encoding])
 * string : 要编码的字符串
 * encoding : 编码
 */
var ffrom = ()=>{
    const buf5 = Buffer.from([1,2,99]);
    console.log(buf5);   
    console.log(buf5.toString());   // 输出对应的ascii的字符
    console.log(buf5[2]);           // '99'

    const buf6 = Buffer.from('test');   // 默认UTF-8字节格式的buffer
    console.log(buf6);                  // '<Buffer 74 65 73 74>'
    console.log(buf6.toString());       // 'test'

    const buf7 = Buffer.from('test', 'latin1'); // Latin-1字节格式的buffer
    console.log(buf7);                  // <Buffer 74 65 73 74>
    console.log(buf7.toString());       // 'test'
}
// ffrom();


/** Buffer.toString([encoding, [start, [end]]])
 * encoding : 编码格式 支持 ascii, utf8, utf16le, ucs2, base64, latin1, binary, hex
 * start ： 开始位置（0 to buf.length-1）
 * end ： 结束位置（不包含该索引位置数据)
 */
// For Example
var f2str = ()=>{
    const buf7 = Buffer.allocUnsafe(256);
    // buf7.fill(1);
    // console.log( buf7.toString(0,10));   ERROR:UnKnown encoding
    console.log( buf7.toString(undefined,0,10));  // encoding 不可为null，可以是undefined
}
// f2str();

/** for...of */
var ffor = ()=>{
    const buf = Buffer.from([1,2,3]);

    for(const b of buf){
        console.log(b); // 遍历
    }
}
// ffor();

Buffer操作，合并，比较，拷贝，剪裁，释放

合并：Buffer.concat(list[,totalLength]);

比较：buf.compare(otherBuffer);    buf.equals(otherBuffer)

拷贝：buf.copy(targetBuffer[, targetStart[, sourcestart[, sourceEnd]]])

剪裁：buf.slice([start[, end]]);

释放：无法手动对buffer实例进行GC，只能依靠V8来进行，我们唯一能做的就是解除对buffer实例的引用。

Buffer转JSON，修改数据编码

代码示例：

var cl = function(data){
    console.log(data);
}
var clstr = function(data){
    console.log(data.toString());
}

///Buffer 操作
/** 合并  Buffer.concat(list[, totalLength])
 * list : 用于合并的Buffer对象数组
 * totalLength : 合并后的Buffer对象总长度
 * 
 * return 新的Buffer对象
 */
var fconcat = function(){
    const buf1 = Buffer.from('Buffer相关操作：');
    const buf2 = Buffer.from('多个buf合并成一个');
    const bufT = Buffer.from('~顺序的重要性~');
    const buf3 = Buffer.concat([buf1, bufT, buf2]);
    clstr(buf3);    //"Buffer相关操作：~顺序的重要性~多个buf合并成一个"
    
    const buf4 = Buffer.concat([buf1, buf2, bufT], 50);// UTF-8一个汉字占用3个字节！Unicode中英统统2个字节
    clstr(buf4);    //"Buffer相关操作：多个buf合并成一个~顺�"
}
// fconcat();


/** 比较  buf.compare(otherbuf);
 * otherbuf : 用作比较的目的Buffer对象
 * 
 * return（-1/0/1）
 * 从第一位开始比对ascii，直到(return ！=0 || 对比位=='\0')return 0; 
 */
var fcompare = function(){
    var buf1 = Buffer.from('abc');
    var buf2 = Buffer.from('abcd');
    var buf3 = Buffer.from('ABC');

    cl(buf1.compare(buf2));     // abc?abcd   -1
    cl(buf1.compare(buf3));     // abc?ABC     1
    cl(buf2.compare(buf3));     // abcd?ABC    1
}
// fcompare();


/** 拷贝  buf.copy(targetBuffer[, targetStart[, sourcestart[, sourceEnd]]])
 * targetBuffer : 被更改的的Buffer对象
 * targetStart : Number,被更改的起始位置
 * sourceStart : Number,开始拷贝的起始位置
 * sourceEnd : Number,拷贝的结束位置
 * 
 * return 被拷贝的字节数
 * *覆盖式 *不会扩充其长度
 */
var fcopy = function(){
    var buf1 = Buffer.from('0123456789');
    var buf2 = Buffer.from('abcde');
    var buf3 = Buffer.from('1234567890');

    // 不会扩充其长度
    buf2.copy(buf3, 2);
    buf1.copy(buf2, 1);

    clstr(buf1);    //"0123456789"
    clstr(buf2);    //"a0123"
    clstr(buf3);    //"12abcde890"
}
// fcopy();


/** 剪裁  buf.slice([start[, end]]);
 * start : number，剪裁开始点  ((start<0) : buf.length + start )
 * end : number，剪裁结束点    ((end<0) : buf.length + end )
 * *start <= end return ''
 */
var fslice = function(){
    var buf1 = Buffer.from('thetestdata');

    var buf2 = buf1.slice();    // thetestdata
    clstr(buf2);
    
    var buf3 = buf1.slice(3);   // testdata
    clstr(buf3);

    var buf4 = buf1.slice(3,7); // test
    clstr(buf4);

    var buf5 = buf1.slice(8,8); // ''
    clstr(buf5);

    var buf6 = buf1.slice(7,3); // ''
    clstr(buf6);

    var buf7 = buf1.slice(-4);
    clstr(buf7);                // 'data'

    var buf8 = buf1.slice(0,100);
    clstr(buf8);                // 'thetestdata'
    cl(buf8.length);            // 11

    var buf9 = buf1.slice(-4,-2);
    clstr(buf9);                // 'da'
}
// fslice();