摘要：是什么存在于全局對(duì)象上，無(wú)需引入模塊即可使用，可見(jiàn)重要性非同一般?？梢岳斫馐窃趦?nèi)存中開(kāi)辟的一片區(qū)域，用于存放二進(jìn)制數(shù)據(jù)。大小通過(guò)參數(shù)指定，默認(rèn)情況下是。一般情況下位系統(tǒng)大約是，位系統(tǒng)大約是。

Buffer存在于全局對(duì)象上，無(wú)需引入模塊即可使用，可見(jiàn)重要性非同一般。
可以理解Buffer是在內(nèi)存中開(kāi)辟的一片區(qū)域，用于存放二進(jìn)制數(shù)據(jù)。Buffer所開(kāi)辟的是堆外內(nèi)存。

怎么理解流呢？流是數(shù)據(jù)的集合（與數(shù)據(jù)、字符串類(lèi)似），但是流的數(shù)據(jù)不能一次性獲取到，數(shù)據(jù)也不會(huì)全部load到內(nèi)存中，因此流非常適合大數(shù)據(jù)處理以及斷斷續(xù)續(xù)返回chunk的外部源。流的生產(chǎn)者與消費(fèi)者之間的速度通常是不一致的，因此需要buffer來(lái)暫存一些數(shù)據(jù)。buffer大小通過(guò)highWaterMark參數(shù)指定，默認(rèn)情況下是16Kb。

Buffer 對(duì)象占用的內(nèi)存空間是不計(jì)算在 Node.js 進(jìn)程內(nèi)存空間限制上的，所以可以用來(lái)存儲(chǔ)大對(duì)象，但是對(duì)象的大小還是有限制的。一般情況下32位系統(tǒng)大約是1G，64位系統(tǒng)大約是2G。

除了流自動(dòng)隱式創(chuàng)建Buffer之外，也可以手動(dòng)創(chuàng)建Buffer，方式如下：

Buffer中存儲(chǔ)的數(shù)據(jù)已確定

Buffer.from(obj) // obj支持的類(lèi)型string, buffer, arrayBuffer, array, or array-like object

注意：Buffer.from不支持傳入數(shù)字，如下所示：

Buffer.from(1234);

buffer.js:208
    throw new errors.TypeError(
    ^

TypeError [ERR_INVALID_ARG_TYPE]: The "value" argument must not be of type number. Received type number
    at Function.from (buffer.js:208:11)
    ...
    

若要傳入數(shù)字可以采用傳入數(shù)組的方式：

const buf = Buffer.from([1, 2, 3, 4]);
console.log(buf); // 

但是這種方式存在一個(gè)問(wèn)題，當(dāng)存入不同的數(shù)值的時(shí)候buffer中記錄的二進(jìn)制數(shù)據(jù)會(huì)相同，如下所示：

const buf2 = Buffer.from([127, -1]);
console.log(buf2);    

const buf3 = Buffer.from([127, 255]);
console.log(buf3);    

console.log(buf3.equals(buf2));  // true

當(dāng)要記錄的一組數(shù)全部落在0到255（readUInt8來(lái)讀?。┻@個(gè)范圍, 或者全部落在-128到127（readInt8來(lái)讀?。┻@個(gè)范圍那么就沒(méi)有問(wèn)題，否則的話就強(qiáng)烈不推薦使用Buffer.from來(lái)保存一組數(shù)。因?yàn)椴煌臄?shù)字讀取時(shí)應(yīng)該調(diào)用不同的方法。

Buffer存儲(chǔ)數(shù)據(jù)未確定

Buffer.alloc、Buffer.allocUnsafe、Buffer.allocUnsafeSlow

Buffer.alloc會(huì)用0值填充已分配的內(nèi)存，所以相比后兩者速度上要慢，但是也較為安全。當(dāng)然也可以通過(guò)--zero-fill-buffers flag使allocUnsafe、allocUnsafeSlow在分配完內(nèi)存后也進(jìn)行0值填充。

node --zero-fill-buffers index.js

當(dāng)分配的空間小于4KB的時(shí)候，allocUnsafe會(huì)直接從之前預(yù)分配的Buffer里面slice空間，因此速度比allocUnsafeSlow要快，當(dāng)大于等于4KB的時(shí)候二者速度相差無(wú)異。

// 分配空間等于
function createBuffer(fn, size) {
  console.time("buf-" + fn);
  for (var i = 0; i < 100000; i++) {
    Buffer[fn](size);
  }
  console.timeEnd("buf-" + fn);
}
createBuffer("alloc", 4096);
createBuffer("allocUnsafe", 4096);
createBuffer("allocUnsafeSlow", 4096);

// 輸出
buf-alloc:           294.002ms
buf-allocUnsafe:     224.072ms
buf-allocUnsafeSlow: 209.22ms

function createBuffer(fn, size) {
  console.time("buf-" + fn);
  for (var i = 0; i < 100000; i++) {
    Buffer[fn](size);
  }
  console.timeEnd("buf-" + fn);
}
createBuffer("alloc", 4095);
createBuffer("allocUnsafe", 4095);
createBuffer("allocUnsafeSlow", 4095);
// 輸出
buf-alloc:           296.965ms
buf-allocUnsafe:     135.877ms
buf-allocUnsafeSlow: 205.225ms

需要謹(jǐn)記一點(diǎn)：new Buffer(xxxx) 方式已經(jīng)不推薦使用了

buffer轉(zhuǎn)字符串

const buf = Buffer.from("test");
console.log(buf.toString("utf8"));                 // test
console.log(buf.toString("utf8", 0, 2));           // te

buffer轉(zhuǎn)json

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
console.log(buf.toJSON());    // { type: "Buffer", data: [ 1, 2, 3, 4, 5 ] }

buffer裁剪，裁剪后返回的新的buffer與原buffer指向同一塊內(nèi)存

buf.slice([start[, end]])
start 起始位置
end 結(jié)束位置(不包含)

示例：

var buf1 = Buffer.from("test");
var buf2 = buf1.slice(1, 3).fill("xx");
console.log("buf2 content: " + buf2.toString()); // xx
console.log("buf1 content: " + buf1.toString()); // txxt

buffer拷貝，buffer與數(shù)組不同，buffer的長(zhǎng)度一旦確定就不再變化，因此當(dāng)拷貝的源buffer比目標(biāo)buffer大時(shí)只會(huì)復(fù)制部分的值

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])

示例：
var buf1 = Buffer.from("abcdefghijkl");
var buf2 = Buffer.from("ABCDEF");

buf1.copy(buf2, 1);
console.log(buf2.toString()); //Abcdef

buffer相等判斷，比較的是二進(jìn)制值

buf.equals(otherBuffer)

示例：
const buf1 = Buffer.from("ABC");
const buf2 = Buffer.from("414243", "hex"); 
console.log(buf1.equals(buf2));    // true

除了equals之外，compare其實(shí)也可以用于判斷是否相等（當(dāng)結(jié)果為0則相等），不過(guò)compare更主要的作用是用于對(duì)數(shù)組內(nèi)的buffer實(shí)例排序。

buffer是否包含特定值

buf.includes(value[, byteOffset][, encoding])
buf.indexOf(value[, byteOffset][, encoding])

示例：
const buf = Buffer.from("this is a buffer");
console.log(buf.includes("this"));  // true
console.log(buf.indexOf("this"));  // 0

寫(xiě)入讀取數(shù)值

寫(xiě)入方法：

write{Double| Float | Int16 | Int32| UInt16 | UInt32 }{BE|LE}(value, offset)

write{Int | UInt}{BE | LE}(value, offset, bytelength) // 此方法提供了更靈活的位數(shù)表示數(shù)據(jù)（比如3位、5位）

write{Int8 | Unit8}(value, offset)

讀取方法：

write{Double| Float | Int16 | Int32 | UInt16 | UInt32 }{BE|LE}（offset)

read{Int | UInt}{BE | LE}(offset, byteLength)

read{Int8 | Unit8}(offset)

Double、Float、Int16、Int32、UInt16、UInt32既確定了表征數(shù)字的位數(shù)，也確定了是否包含負(fù)數(shù)，因此定義了不同的數(shù)據(jù)范圍。同時(shí)由于表征數(shù)字的位數(shù)都超過(guò)8位，無(wú)法用一個(gè)字節(jié)來(lái)表示，因此就涉及到了計(jì)算機(jī)的字節(jié)序區(qū)分（大端字節(jié)序與小端字節(jié)序）

關(guān)于大端小端的區(qū)別可以這么理解：數(shù)值的高位在buffer的起始位置的是大端，數(shù)值的低位buffer的起始位置則是小端

const buf = Buffer.allocUnsafe(2);
buf.writeInt16BE(256, 0)  
console.log(buf);           //  
buf.writeInt16LE(256, 0)
console.log(buf);           // 

https://tool.lu/hexconvert/ 這里可以查看數(shù)值的不同進(jìn)制之間的轉(zhuǎn)換，如果是大端的話，則直接按順序（0100）拼接16進(jìn)制即可，如果是小端則需要調(diào)換一下順序才是正確的表示方式。

buffer合并

Buffer.concat(list[, totalLength]) //totalLength不是必須的，如果不提供的話會(huì)為了計(jì)算totalLength會(huì)多一次遍歷

const buf1 = Buffer.from("this is");
const buf2 = Buffer.from(" funny");
console.log(Buffer.concat([buf1, buf2], buf1.length + buf2.length));
// 

清空buffer

清空buffer數(shù)據(jù)最快的辦法是buffer.fill(0)

Buffer是全局global上的一個(gè)引用，指向的其實(shí)是buffer.Buffer

 const buffer = require("buffer");
 console.log(buffer.Buffer === Buffer); //true

buffer模塊上還有其他一些屬性和方法

const buffer = require("buffer");
console.log(buffer);
{ Buffer:
   { [Function: Buffer]
     poolSize: 8192,
     from: [Function: from],
     alloc: [Function: alloc],
     allocUnsafe: [Function: allocUnsafe],
     allocUnsafeSlow: [Function: allocUnsafeSlow],
     isBuffer: [Function: isBuffer],
     compare: [Function: compare],
     isEncoding: [Function: isEncoding],
     concat: [Function: concat],
     byteLength: [Function: byteLength],
     [Symbol(node.isEncoding)]: [Function: isEncoding] },
  SlowBuffer: [Function: SlowBuffer],
  transcode: [Function: transcode],
  INSPECT_MAX_BYTES: 50,
  kMaxLength: 2147483647,
  kStringMaxLength: 1073741799,
  constants: { MAX_LENGTH: 2147483647, MAX_STRING_LENGTH: 1073741799 } }

上面的kMaxLength與MAX_LENGTH代表了新建buffer時(shí)內(nèi)存大小的最大值，當(dāng)超過(guò)限制值后就會(huì)報(bào)錯(cuò)

32為機(jī)器上是(2^30)-1(~1GB)

64位機(jī)器上是(2^31)-1(~2GB)

我們無(wú)法手動(dòng)對(duì)buffer實(shí)例進(jìn)行GC，只能依靠V8來(lái)進(jìn)行，我們唯一能做的就是解除對(duì)buffer實(shí)例的引用

http://cenalulu.github.io/lin...

http://www.ruanyifeng.com/blo...

https://medium.freecodecamp.o...

https://www.barretlee.com/blo...

https://medium.freecodecamp.o...

http://www.runoob.com/nodejs/...