node.js Buffer

在js中基础类型没有二进制byte类型，但是js提供了ArrayBuffer群来处理各种二进制的存储，而node.js也为我们封装了一个用于存储二进制的通用Buffer类，这里说说Buffer。

 

1.Buffer构造：

function Buffer(subject, encoding, offset) {
  if (!(this instanceof Buffer)) {
    return new Buffer(subject, encoding, offset);
  }

  var type;

  // Are we slicing?
  if (typeof offset === 'number') {
    if (!Buffer.isBuffer(subject)) {
      throw new TypeError('First argument must be a Buffer when slicing');
    }

    this.length = +encoding > 0 ? Math.ceil(encoding) : 0;
    this.parent = subject.parent ? subject.parent : subject;
    this.offset = offset;
  } else {
    // Find the length
    switch (type = typeof subject) {
      case 'number':
        this.length = +subject > 0 ? Math.ceil(subject) : 0;
        break;

      case 'string':
        this.length = Buffer.byteLength(subject, encoding);
        break;

      case 'object': // Assume object is array-ish
        this.length = +subject.length > 0 ? Math.ceil(subject.length) : 0;
        break;

      default:
        throw new TypeError('First argument needs to be a number, ' +
                            'array or string.');
    }

    // Buffer.poolSize 这里的poolSize默认大小是8KB
    if (this.length > Buffer.poolSize) {
      // Big buffer, just alloc one.   大于8kb的buffer将重新分配内存
      this.parent = new SlowBuffer(this.length); // SlowBuffer才是真正存储的地方，这里的长度为buffer的真实长度，大于8KB
      this.offset = 0;

    } else if (this.length > 0) {
      // Small buffer. 当new的buffer小于8KB的时候，就会把多个buffer放到同一个allocPool 的SlowBuffer里面
      if (!pool || pool.length - pool.used < this.length) allocPool(); // 当前已有的allocPool大小不够，如是重新分配一个allocPool,新分配的allocPool成为当前活动的allocPool
      this.parent = pool; 
      this.offset = pool.used;
      // Align on 8 byte boundary to avoid alignment issues on ARM.
      pool.used = (pool.used + this.length + 7) & ~7; // 将pool原本使用的大小变成8的倍数，例如你实际用了9byte，它会说你用了16byte，这样你就浪费了7byte，目的是提供性能。

    } else {
      // Zero-length buffer 如果当前pool够放，就直接放进去
      this.parent = zeroBuffer;
      this.offset = 0;
    }

    // 下面这部分是写操作
    // optimize by branching logic for new allocations
    if (typeof subject !== 'number') {
      if (type === 'string') {
        // We are a string
        this.length = this.write(subject, 0, encoding);
      // if subject is buffer then use built-in copy method
      } else if (Buffer.isBuffer(subject)) {
        if (subject.parent)
          subject.parent.copy(this.parent,
                              this.offset,
                              subject.offset,
                              this.length + subject.offset);
        else
          subject.copy(this.parent, this.offset, 0, this.length);
      } else if (isArrayIsh(subject)) {
        for (var i = 0; i < this.length; i++)
          this.parent[i + this.offset] = subject[i];
      }
    }
  }

  SlowBuffer.makeFastBuffer(this.parent, this, this.offset, this.length);
}

我们创建一个buffer的时候，本质上内容是存放在SlowBuffer里面的，由于node.js对小于8KB的buffer做了pool处理，你可以理解为buffer池。正是这个原因出现了几种情况：

1.buffer大于8KB：这种情况下buffer直接使用一个SlowBuffer存放数据，不使用pool存储。

2.buffer小于8KB：小于的时候会检测当前pool够不够放，不够放就重新分配一个pool，然后新分配的pool就成了当前pool。这个时候之前的那个pool里面空出来的内存就直接浪费掉了。

3.如果当前pool足够容纳buffer，就直接放到当前pool里面，一个pool里面可以存放多个buffer。

针对2和3这种pool的情况，如果buffer的长度不是8的倍数，将会自动补齐。这样也会浪费掉一些空间。

Buffer.poolSize = 8 * 1024;
var pool; // 看到没，allocPool的时候新的会把旧的pool直接替换掉，这样旧的pool里面没用到的内存就浪费了。其实这种浪费并不可怕，可怕的是buffer的不正常释放导致整个pool内存无法被gc回收形成真正的内存泄露。

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

 8KB事件：网传的8KB事件其实可以算做是一个buffer的错误用法，直接将buffer的引用置为null，最后用gc进行清理内存。由于pool里面有几个空余的内存无法释放，导致整个pool都无法被回收。这也说明，我们在使用buffer的时候最好手动清空buffer。

 

2.写入操作：

function Buffer(subject, encoding, offset) ：利用构造方法，构造的时候直接传入内容，这个内容可以是多种对象，string，数组，objet等。

concat(list, [totalLength])：这个方法是把list里面的buffer合并到一起。

Buffer.concat = function(list, length) {
  if (!Array.isArray(list)) {
    throw new TypeError('Usage: Buffer.concat(list, [length])');
  }

  if (list.length === 0) { // 当list长度为0时，返回一个长度为0的buffer
    return new Buffer(0);
  } else if (list.length === 1) { // 当list长度为1时，返回list[0];，其实就是自己
    return list[0];
  }

  if (typeof length !== 'number') { // 如果length没有值，就会计算list里面所有buffer的总长度
    length = 0;
    for (var i = 0; i < list.length; i++) {
      var buf = list[i];
      length += buf.length;
    }
  }

  var buffer = new Buffer(length); // buffer的分配是固定的，不是可变长的
  var pos = 0;
  for (var i = 0; i < list.length; i++) { // 把所有的buffer组合到一起
    var buf = list[i];
    buf.copy(buffer, pos);
    pos += buf.length;
  }
  return buffer;
};

 

buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd])：

Buffer.prototype.copy = function(target, target_start, start, end) {
  // set undefined/NaN or out of bounds values equal to their default
  if (!(target_start >= 0)) target_start = 0;
  if (!(start >= 0)) start = 0;
  if (!(end < this.length)) end = this.length;

  // Copy 0 bytes; we're done
  if (end === start ||
      target.length === 0 ||
      this.length === 0 ||
      start > this.length)
    return 0;

  if (end < start)
    throw new RangeError('sourceEnd < sourceStart');

  if (target_start >= target.length)
    throw new RangeError('targetStart out of bounds');

  if (target.length - target_start < end - start) // 这里需要注意，如果长度不够源的拷贝就会被截取
    end = target.length - target_start + start;

  // 最蛋疼的是这句话，parent.copy是啥真没理解，我对js的继承很蛋疼啊，一直搞不懂。有人说这里用的是slowbuffer的copy方法，但是在代码里面没有看到它的copy方法
  return this.parent.copy(target.parent || target, 
                          target_start + (target.offset || 0),
                          start + this.offset,
                          end + this.offset);
};

target：拷贝到的目标位置，这里需要注意的是目标buffer内存的大小是需要比源大的，否则不会拷贝的。

target_start：目标的起始位置

start：源的起始位置

end：源的结束位置，不能超过length，超过就设置为length。

这里需要注意的是：1.如果根本不能执行拷贝，会报异常这个还好。2.能拷贝但是目标的存放位置不够，这个时候就会出现截取，这个肯定不是我们想看到的，也是需要注意的。

 

Buffer.prototype.write = function(string, offset, length, encoding)：

Buffer.prototype.write = function(string, offset, length, encoding) {
  // Support both (string, offset, length, encoding)
  // and the legacy (string, encoding, offset, length)
  if (isFinite(offset)) {
    if (!isFinite(length)) {
      encoding = length;
      length = undefined;
    }
  } else {  // legacy
    var swap = encoding;
    encoding = offset;
    offset = length;
    length = swap;
  }

  offset = +offset || 0;
  var remaining = this.length - offset;
  if (!length) {
    length = remaining;
  } else {
    length = +length;
    if (length > remaining) {
      length = remaining;
    }
  }
  encoding = String(encoding || 'utf8').toLowerCase(); // 这个是关键，这说明js的String对象写入到buffer的时候，默认字符编码为utf-8

  if (string.length > 0 && (length < 0 || offset < 0))
    throw new RangeError('attempt to write beyond buffer bounds');

  // 在这之上的是对参数进行处理，在这之下的是写入操作，针对不同的编码格式调用不同的方法。
  var ret;
  switch (encoding) {
    case 'hex':
      ret = this.parent.hexWrite(string, this.offset + offset, length);
      break;

    case 'utf8':
    case 'utf-8':
      ret = this.parent.utf8Write(string, this.offset + offset, length);
      break;

    case 'ascii':
      ret = this.parent.asciiWrite(string, this.offset + offset, length);
      break;

    case 'binary':
      ret = this.parent.binaryWrite(string, this.offset + offset, length);
      break;

    case 'base64':
      // Warning: maxLength not taken into account in base64Write
      ret = this.parent.base64Write(string, this.offset + offset, length);
      break;

    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      ret = this.parent.ucs2Write(string, this.offset + offset, length);
      break;

    default:
      throw new TypeError('Unknown encoding: ' + encoding);
  }

  Buffer._charsWritten = SlowBuffer._charsWritten;

  return ret;
};

// 实现很简单，调用了底层的写入方法
Buffer.prototype.utf8Write = function(string, offset) {
  return this.write(string, offset, 'utf8');
};

Buffer.prototype.binaryWrite = function(string, offset) {
  return this.write(string, offset, 'binary');
};

Buffer.prototype.asciiWrite = function(string, offset) {
  return this.write(string, offset, 'ascii');
};

 

buf.fill(value, [offset], [end])：填充，填充的内容是value的内容，如果value是字符串的话，填充的是value = value.charCodeAt(0);值。

 

3.读取操作：

SlowBuffer.prototype.toString = function(encoding, start, end)：大同小异这里只是贴出来，最喜的是默认为utf-8格式，因为我客户端传过来的数据就是utf-8，这样就不用转换了。

SlowBuffer.prototype.toString = function(encoding, start, end) {
  encoding = String(encoding || 'utf8').toLowerCase();
  start = +start || 0;
  if (typeof end !== 'number') end = this.length;

  // Fastpath empty strings
  if (+end == start) {
    return '';
  }

  switch (encoding) {
    case 'hex':
      return this.hexSlice(start, end);

    case 'utf8':
    case 'utf-8':
      return this.utf8Slice(start, end);

    case 'ascii':
      return this.asciiSlice(start, end);

    case 'binary':
      return this.binarySlice(start, end);

    case 'base64':
      return this.base64Slice(start, end);

    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return this.ucs2Slice(start, end);

    default:
      throw new TypeError('Unknown encoding: ' + encoding);
  }
};

Buffer.prototype.utf8Slice = function(start, end) {
  return this.toString('utf8', start, end);
};

Buffer.prototype.binarySlice = function(start, end) {
  return this.toString('binary', start, end);
};

Buffer.prototype.asciiSlice = function(start, end) {
  return this.toString('ascii', start, end);
};

Buffer.prototype.utf8Write = function(string, offset) {
  return this.write(string, offset, 'utf8');
};

Buffer.prototype.binaryWrite = function(string, offset) {
  return this.write(string, offset, 'binary');
};

Buffer.prototype.asciiWrite = function(string, offset) {
  return this.write(string, offset, 'ascii');
};

 

Buffer.prototype.toJSON：把buffer直接转换成json对象输出

Buffer.prototype.toJSON = function() {
  return Array.prototype.slice.call(this, 0);
};

 Buffer.prototype.slice = function(start, end) ：这个方法感觉跟拷贝差不多，但是算是各有利弊吧。它在操作的同时不会损害原有的buffer里面的内容。

 

Buffer.prototype.get = function get(offset) {
  if (offset < 0 || offset >= this.length)
    throw new RangeError('offset is out of bounds');
  return this.parent[this.offset + offset];
};


Buffer.prototype.set = function set(offset, v) {
  if (offset < 0 || offset >= this.length)
    throw new RangeError('offset is out of bounds');
  return this.parent[this.offset + offset] = v;
};

 这两个方法也是读写方法，而且还比较简洁，如果对buffer对象自身进行操作可以用这个。