在 Node.js 中，Buffer 经常用来存储一些潜伏的大抵积数据，比方，文件和收集 I/O 所获取来的数据，若不指定编码，则都以 Buffer 的情势来供应，可见其职位非同一般。你也许听说过，Buffer 的建立，是能够会经由内部的一个 8KB 池的，那末详细的划定规矩是什么呢？能够建立一个新 Buffer 实例的 API 那末多，终究哪些 API 会经由，哪些又不会经由呢？也许你在浏览文档时，还看到过很多形如 Buffer#writeUInt32BE ， Buffer#readUInt32BE 等等这类牢固位的数字的读写操纵，它们详细是怎样完成的呢？
如今让我们一同随着 Node.js 项目中 lib/buffer.js 中的代码，来一探终究。
8KB 池分派划定规矩
统计一下，当前版本的 Node.js （v6.0）中能够建立一个新 Buffer 类实例的 API 有：
new Buffer()（已不引荐运用，能够会泄漏内存中潜伏的敏感信息，详细例子能够看这里）Buffer.alloc()Buffer.allocUnsafe()（虽然也有泄漏内存中敏感信息的能够，但语义上异常明白）Buffer.from()Buffer.concat()
随着代码追溯，这些 API 末了都邑走进两个内部函数中的一个，来建立 Buffer 实例，这两个内部函数分别是 createBuffer() 和 allocate()：
// lib/buffer.js
// ...
Buffer.poolSize = 8 * 1024;
var poolSize, poolOffset, allocPool;
function createPool() {
poolSize = Buffer.poolSize;
allocPool = createBuffer(poolSize, true);
poolOffset = 0;
}
createPool();
function createBuffer(size, noZeroFill) {
flags[kNoZeroFill] = noZeroFill ? 1 : 0;
try {
const ui8 = new Uint8Array(size);
Object.setPrototypeOf(ui8, Buffer.prototype);
return ui8;
} finally {
flags[kNoZeroFill] = 0;
}
}
function allocate(size) {
if (size === 0) {
return createBuffer(size);
}
if (size < (Buffer.poolSize >>> 1)) {
if (size > (poolSize - poolOffset))
createPool();
var b = allocPool.slice(poolOffset, poolOffset + size);
poolOffset += size;
alignPool();
return b;
} else {
return createBuffer(size, true);
}
}经由过程代码能够清晰的看到，若末了建立时，走的是 createBuffer() 函数，则不经由 8KB 池，若走 allocate() 函数，当传入的数据大小小于 Buffer.poolSize 有标记右移 1 位后的效果（相当于将该值除以 2 再向下取整，在本例中，为 4 KB），才会运用到 8KB 池（若当前池盈余空间不足，则建立一个新的，并将当前池指向新池）。
那末如今让我们来看看，这些 API 都走的是哪些要领：
// lib/buffer.js
// ...
Buffer.alloc = function(size, fill, encoding) {
// ...
return createBuffer(size);
};
Buffer.allocUnsafe = function(size) {
assertSize(size);
return allocate(size);
};
Buffer.from = function(value, encodingOrOffset, length) {
// ...
if (value instanceof ArrayBuffer)
return fromArrayBuffer(value, encodingOrOffset, length);
if (typeof value === 'string')
return fromString(value, encodingOrOffset);
return fromObject(value);
};
function fromArrayBuffer(obj, byteOffset, length) {
byteOffset >>>= 0;
if (typeof length === 'undefined')
return binding.createFromArrayBuffer(obj, byteOffset);
length >>>= 0;
return binding.createFromArrayBuffer(obj, byteOffset, length);
}
function fromString(string, encoding) {
// ...
if (length >= (Buffer.poolSize >>> 1))
return binding.createFromString(string, encoding);
if (length > (poolSize - poolOffset))
createPool();
var actual = allocPool.write(string, poolOffset, encoding);
var b = allocPool.slice(poolOffset, poolOffset + actual);
poolOffset += actual;
alignPool();
return b;
}
Buffer.concat = function(list, length) {
// ...
var buffer = Buffer.allocUnsafe(length);
// ...
return buffer;
};挺一览无余的，让我们来总结一下，当在以下状况同时都成立时，建立的新的 Buffer 类实例才会经由内部 8KB 池：
经由过程
Buffer.allocUnsafe，Buffer.concat，Buffer.from（参数不为一个 ArrayBuffer 实例）和new Buffer（参数不为一个 ArrayBuffer 实例）建立。传入的数据大小不为 0 。
且传入数据的大小必需小于 4KB 。
那些牢固位数字读写 API
当你在浏览 Buffer 的文档时，看到诸如 Buffer#writeUInt32BE，Buffer#readUInt32BE 如许的 API 时，能够会想到 ES6 范例中的 DateView 类供应的那些要领。实在它们做的事变非常相似，Node.js 项目中以至另有将这些 API 的底层都替换成原生的 DateView 实例来操纵的 PR ，但该 PR 现在已被标记为 stalled ，详细缘由大抵是：
没有明显的机能提拔。
会在实例被初始化后又增添新的属性。
noAssert参数将会失效。
先不论这个 PR ，实在，这些读写操纵，若数字的精度在 32 位以下，则对应要领都是由 JavaScript 完成的，非常文雅，利用了 TypeArray 下那些类（Buffer 中运用的是 Uint8Array）的实例中的元素，在位溢出时，会扬弃溢出位的机制。以 writeUInt32LE 和 writeUInt32BE （LE 和 BE 即小端字节序和大端字节序，能够参阅这篇文章）为例，一个 32 位无标记整数须要 4 字节存储，大端字节序时，则第一个元素为直接将传入的 32 位整数无标记右移 24 位，获取到原最左的 8 位，扬弃当下左侧的一切位。以此类推，第二个元素为无标记右移 16 位，第三个元素为 8 位，第四个元素无需挪动（小端字节序则相反）：
Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0);
this[offset] = (value >>> 24);
this[offset + 1] = (value >>> 16);
this[offset + 2] = (value >>> 8);
this[offset + 3] = value;
return offset + 4;
};读操纵与之对应，运用了无标记左移后腾出空位再举行 | 操纵兼并：
Buffer.prototype.readUInt32BE = function(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert)
checkOffset(offset, 4, this.length);
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3]);
};个中的 (this[offset] * 0x1000000) + 相当于 this[offset] << 24 | 。
末了
参考：
