node buffer

Buffer结构

• 类似Array，为16进制的两位数，即占一个字节
• js与c++结合的模块，内存由c++申请，js分配。因为v8垃圾回收影响性能
• node启动时就加载，放在全局对象global

var buf = new Buffer(100);
console.log(buf.length); // => 100

如给buffer赋值数字，则范围在0-255,否则负数就加256,过大就减256

内存使用slab分配机制，动态内存管理，包含三种状态（full,partial,empty）。Node以8KB为界限区分Buffer是大对象还是小对象（Buffer.poolSize=8*1024），即8kb为slab单元大小，js以它为单元分配内存

分配小Buffer对象

• 小于8kb

使用局部变量pool,让处于分配状态的slab单元指向它

var pool;

function allocPool() {
    pool = new SlowBuffer(Buffer.poolSize);
    pool.used = 0;
}

新建小buffer时，如果还没pool,就创建一个slab指向它，当前的buffer对象的parent指向slab

this.parent = pool; //当前的buffer对象的parent指向slab
this.offset = pool.used;//slab开始使用的位置
pool.used += this.length;//slab已使用量
if (pool.used & 7) pool.used = (pool.used + 8) & ~7;

此时slab状态为partial,在创建buffer时会判断次slab是否够用，如果不够，就构建新的slab,原来的slab剩余的空间浪费，如果不释放就占据8kb

分配大Buffer

直接分配一个SlowBuffer对象作为slab单元，并且独占

// Big buffer,just alloc one  SlowBuffer由c++定义,勿直接操作它
this.parent=new SlowBuffer(this.length);this.offset=0;

Buffer对象是js层面的，能被v8标记回收，但其内部parent指向SlowBuffer,由c++提供的Buffer,所以内存由c++提供，js只是使用它，对于小buffer的频繁操作，使用slab机制来先申请后分配，减少内存申请的系统调用，对于大buffe就直接用C++提供内存

Buffer转换

• 支持的字符串编码 ASCII,UTF-8,UTF-16LE/UCS-2,Base64,Binary,Hex

字符串与Buffer的转换

字符串转buffer,使用构造函数new Buffer(str,[encoding]);默认UTF-8

一个Buffer对象可以存多种编码类型的字符串转码的值

buf.write(string, [offset], [length], [encoding])

buffer转字符串

buf.toString([encoding], [start], [end]) //encoding默认UTF-8,配合start和end实现局部转换

Buffer不支持的编码类型

• 使用Buffer.isEncoding(encoding)判断

iconv 通过c++调用libiconv
iconv-lite使用纯js实现，但基于v8高性能，少了c++到js的转换，所以比C++实现好

var iconv = require("iconv-lite");var str = iconv.decode(buf,"win1251");
var buf = iconv.encode('Sample input string', 'win1251');

对无法转换的内容会降级处理，输出部分或者？

Buffer拼接

var fs = require('fs');
var rs = fs.createReadStream('test.md');
var data = '';
rs.on("data", function(chunk) {
    data += chunk; //等价于data = data.toString() + chunk.toString();此处对宽字节的中文可能造成乱码，即字节没读全就转码
});
rs.on("end", function() {
    console.log(data);
});

解决乱码问题

• 在调用setEncoding()时，可读流对象在内部设置一个decoder对象

req.setEncoding('utf8');

var StringDecoder = require('string_decoder').StringDecoder;
var decoder = new StringDecoder('utf8');
var buf1 = new Buffer([0xE5, 0xBA, 0x8A, 0xE5, 0x89, 0x8D, 0xE6, 0x98, 0x8E, 0xE6, 0x9C]);
console.log(decoder.write(buf1));
// => 床前明
var buf2 = new Buffer([0x88, 0xE5, 0x85, 0x89, 0xEF, 0xBC, 0x8C, 0xE7, 0x96, 0x91, 0xE6]);
console.log(decoder.write(buf2));
// =>月光，凝

StringDecoder在得到编码后，知道宽字节在utf-8下占3个字节，所以在处理末尾不全的字节时，会保留到第二次write().目前只能处理UTF-8、Base64和UCS-2/UTF-16LE

正确拼接Buffer

var chunks = [];
var size = 0;
res.on('data', function(chunk) {
    chunks.push(chunk);
    size += chunk.length;
});
res.on('end', function() {
    var buf = Buffer.concat(chunks, size);
    var str = iconv.decode(buf, 'utf8');
    console.log(str);
});

用数组来储存接收的所有Buffer片段并记录总长度，然后调用Buffer.concat()-->

Buffer.concat = function(list, length) {
    if (!Array.isArray(list)) {
        throw new Error('Usage: Buffer.concat(list, [length])');
    }
    if (list.length === 0) {
        return new Buffer(0);
    } else if (list.length === 1) {
        return list[0];
    }
    if (typeof length !== 'number') {
        length = 0;
        for (var i = 0; i < list.length; i++) {
            var buf = list[i];
            length += buf.length;
        }
    }
    var buffer = new Buffer(length);
    var pos = 0;
    for (var i = 0; i < list.length; i++) {
        var buf = list[i];
        buf.copy(buffer, pos);
        pos += buf.length;
    }
    return buffer;
};

Buffer与性能

Buffer广泛应用于文件I/O和网络I/O,尤其在网络传输，使用Buffer比直接使用字符串要性能要高很多。在web开发中对于静态内容可以预先转成buffer,在不需要改变内容时，只读取buffer,不做转换

文件读取

fs.createReadStream()先在内存中准备一段buffer,然后在fs.read()读取时逐步将磁盘中的字节复制到buffer,读完一次就用slice()从buffer取出部分作为小buffer通过data事件传给调用方。Buffer用完会重新分配

fs.createReadStream(path, opts)
//参数
{
    flags: 'r',
    encoding: null,
    fd: null,
    mode: 0666,
    highWaterMark: 64 * 1024 // 每次读取的长度
}

重新分配

var pool;//常驻内存

function allocNewPool(poolSize) {
    pool = new Buffer(poolSize);
    pool.used = 0;
}
//当pool剩余数量小于128(kMinPoolSpace)字节时，会重新分配
if (!pool || pool.length - pool.used < kMinPoolSpace) { 
// discard the old pool
    pool = null;
    allocNewPool(this._readableState.highWaterMark);
}

highWaterMark的大小对性能的影响有：buffer内存的分配和使用、系统调用次数;

• 文件流读取基于buffer,buffer基于slowbuffer，文件小于8kb可能造成slab浪费
• fs.createReadStream()内部使用fs.read()，会引起系统对磁盘的调用，highWaterMark的大小决定调用次数和data事件次数