Node.js API —— Buffer（緩衝區）

// 說明

    Node API 版本爲 v0.10.31。
    中文參考：http://nodeapi.ucdok.com/#/api/，http://blog.sina.com.cn/oleoneoy

    本段爲博主註解。

目錄

● 緩衝區
    ○ Class: Buffer

       ■ new Buffer(size)
       ■ new Buffer(array)
       ■ new Buffer(str, [encoding])
       ■ Class Method: Buffer.isEncoding(encoding)
       ■ buf.write(string, [offset], [length], [encoding])
       ■ buf.toString([encoding], [start], [end])
       ■ buf.toJSON()
       ■ buf[index]
       ■ Class Method: Buffer.isBuffer(obj)
       ■ Class Method: Buffer.byteLength(string, [encoding])
       ■ Class Method: Buffer.concat(list, [totalLength])
       ■ buf.length
       ■ buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd])
       ■ buf.slice([start], [end])
       ■ buf.readUInt8(offset, [noAssert])
       ■ buf.readUInt16LE(offset, [noAssert])
       ■ buf.readUInt16BE(offset, [noAssert])

       ■ buf.readUInt32LE(offset, [noAssert])
       ■ buf.readUInt32BE(offset, [noAssert])
       ■ buf.readInt8(offset, [noAssert])
       ■ buf.readInt16LE(offset, [noAssert])
       ■ buf.readInt16BE(offset, [noAssert])
       ■ buf.readInt32LE(offset, [noAssert])
       ■ buf.readInt32BE(offset, [noAssert])
       ■ buf.readFloatLE(offset, [noAssert])
       ■ buf.readFloatBE(offset, [noAssert])
       ■ buf.readDoubleLE(offset, [noAssert])
       ■ buf.readDoubleBE(offset, [noAssert])
       ■ buf.writeUInt8(value, offset, [noAssert])
       ■ buf.writeUInt16LE(value, offset, [noAssert])
       ■ buf.writeUInt16BE(value, offset, [noAssert])
       ■ buf.writeUInt32LE(value, offset, [noAssert])
       ■ buf.writeUInt32BE(value, offset, [noAssert])
       ■ buf.writeInt8(value, offset, [noAssert])
       ■ buf.writeInt16LE(value, offset, [noAssert])
       ■ buf.writeInt16BE(value, offset, [noAssert])
       ■ buf.writeInt32LE(value, offset, [noAssert])
       ■ buf.writeInt32BE(value, offset, [noAssert])
       ■ buf.writeFloatLE(value, offset, [noAssert])
       ■ buf.writeFloatBE(value, offset, [noAssert])
       ■ buf.writeDoubleLE(value, offset, [noAssert])
       ■ buf.writeDoubleBE(value, offset, [noAssert])
       ■ buf.fill(value, [offset], [end])
    ○ buffer.INSPECT_MAX_BYTES
    ○ Class: SlowBuffer

 

 緩衝區

穩定性：3 - 穩定

    純粹的 JavaScript 是 Unicode 友好的，但對二進制數據並不是這樣。當處理 TCP 流和文件流的時候，須要處理字節流。Node 有若干種方法來操做，建立和消費字節流。
    原始數據保存在 Buffer 類的實例中。一個 Buffer 和一個整數數組相似，但對應 V8 堆內存以外的原始內存分配區域。一個 Buffer 不能重置大小。
    Buffer 類是全局變量，令其很是罕見地不須要 require('buffer')。
    在 Buffer 和 JavaScript 字符串對象間轉換須要明確的編碼方法。下面是不一樣的字符串編碼。

• 'ascii'——只有7位 ASCII 數據。這種編碼方法很是快，且會忽略最高位若是設置了的話。注意若是從字符串轉換成緩衝區，這種編碼將空字符（'\0' 或 '\u0000'）轉換成 0x20（空格的字符編碼）。若是你想講空字符轉換成 0x00，你應該使用 'utf8'。
• 'utf8'——多字節編碼的 Unicode 字符。不少 web 頁面和其餘文檔格式使用 UTF-8。
• 'utf16le'——2或4字節，小端編碼的 Unicode 字符。代理對（U+10000 至 U+10FFF）是被支持的。
• 'ucs2'——'utf16le' 的別名。
• 'base64'——Base64 字符串編碼。
• 'binary'——只使用每一個字符的前8位來將原始二進制數據編碼成字符串的一種方式。這種編碼方法是被反對的，且若如可能應避免使用並用 Buffer 對象取代。這種編碼將在 Node 的將來版本移除。
• 'hex'——將每一個字節編碼成兩個十六進制字符。

    從一個 Buffer 建立一個指定類型的數組有如下注意事項：

1. buffer 的內存是複製的，不是共享的。
2. buffer 的內存看成成一個數組，而不是字節數組。亦即，new Uint32Array(new Buffer([1, 2, 3, 4]) 建立一個帶有元素 [1, 2, 3, 4] 的4元素 Uint32Array，而不是隻有一個元素 [0x1020304] 或 [0x4030201] 的 Uint32Array。

    注意：Node.js v0.8 簡單地記住 array.buffer 中的緩衝區引用而不是複製它。
    當更高效地，它對指定類型的數組規格引入了微妙的不兼容。ArrayBuffer #slice() 從切片複製一份拷貝，而 Buffer #slice() 建立一個視圖。

Class: Buffer

    Buffer 類是一個用來直接處理二進制數據的全局類型。它能夠用多種方式構造。

new Buffer(size)

• size 數值類型

    分配一個 size 字節的新緩衝區。

new Buffer(array)

• array 數組類型

    使用 array 做爲字節數組分配新的緩衝區。

new Buffer(str, [encoding])

• str 字符串類型 —— 需編碼的字符串。
• encoding 字符串類型 —— 使用的編碼，可選。

    分配一個包含給出的 str 的新緩衝區。encoding 默認爲 'utf8'。

Class Method: Buffer.isEncoding(encoding)

• encoding 字符串類型 —— 要測試的編碼的字符串

    若是 encoding 是有效的編碼參數返回 true，不然返回 false。

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

• string 字符串類型 —— 要寫入緩衝區的數據
• offset 數值類型，可選，默認值：0
• length 數值類型，可循環，默認值：buffer.length - offset
• encoding 字符串類型，可選，默認值：'utf8'

    使用給出的編碼將 string 寫入緩衝區的 offset 位置。offset 默認爲0，encoding 默認爲 'utf8'。length 是要寫入的字節數量。返回寫入的字節數量。若是 buffer 沒有足夠的空間來容納整個字符串，它將寫入字符串的一部分。length 默認爲 buffer.length - offset。本方法不會寫入字符的一部分。

1 buf = new Buffer(256);
2 len = buf.write('\u00bd + \u00bc = \u00be', 0);
3 console.log(len + "bytes: " + buf.toString('utf8', 0, len));

    寫入的字符數量（可能與寫入的字節數量不相同）在 Buffer._charWritten 中設置，並會在下一次 buf.write() 調用時重寫。

buf.toString([encoding], [start], [end])

• encoding 字符串類型，可選，默認值：'utf8'
• start 數值類型，可選，默認值：0
• end 數值類型，可選，默認值：buffer.length

    從使用 encoding（默認爲 'utf8'）編碼以 start（默認爲0）開始到 end（默認爲 buffer.length）結束的緩衝區數據解碼並返回一個字符串。
    參看以上 buffer.write() 的例子。

buf.toJSON()

    返回 Buffer 實例的 JSON 表示，這與 JSON 的數組的輸出是一致的。當序列化一個 Buffer 實例時 JSON.stringify 會隱含地調用這個函數。
    例子：

1 var buf = new Buffer('test');
2 var json = JSON.stringify(buf);
3 
4 console.log(json);
5 // '[116,101,115,116]'
6 
7 var copy = new Buffer(JSON.parse(json));
8 console.log(copy);
9 // <Buffer 74 65 73 74>

buf[index]

    獲取和設置 index 處的字節。這個值指定爲單個字節的值，因此合法的範圍是在十六進制的 0x00 和 0xFF 或 0 和 255 之間。
    例子：複製一個 ASCII 字符串至緩衝區中，一次一個字節：

 1 str = "node.js";
 2 buf = new Buffer(str.length);
 3 
 4 for (var i = 0; i < str.length; i++) {
 5   buf[i] = str.charCodeAt(i);
 6 }
 7 
 8 console.log(buf);
 9 
10 // node.js

Class Method: Buffer.isBuffer(obj)

• obj 對象類型
• 返回值：布爾類型

    測試 obj 是不是一個 Buffer。

Class Method: Buffer.byteLength(string, [encoding])

• string 字符串類型
• encoding 字符串類型，可選，默認值：'utf8'
• 返回值：數值類型

    給出字符串的實際字節數。encoding 默認爲 'utf8'。這與 String.prototype.length 不同，由於那返回字符串的字符數量。
    例子：

1 str = '\u00bd + \u00bc = \u00be';
2 
3 console.log(str + ": " + str.length + " characters, " +
4     Buffer.byteLength(str, 'utf8') + " bytes");
5 
6 // ½ + ¼ = ¾: 9 characters, 12 bytes 

Class Method: Buffer.concat(list, [totalLength])

• list 數組類型 待鏈接的 Buffer 對象數組
• totalLength 數值類型 鏈接後的總長度

    返回把 list 中的全部 buffer 鏈接到一塊兒的 buffer。
    若是 list 中沒有元素，或 totalLength 爲 0，那麼將返回一個 0 長的 buffer。
    若是 list 只有一個元素，那麼 list 中的第一個元素將被返回。
    若是 list 有多於一個元素，那麼返回一個新的 Buffer。
    若是 totalLength 沒有提供，將從 list 中讀取。不過，這將在這個函數的執行中添加一個額外的循環，因此明確提供一個長度將更快些。

buf.length

• 數值類型

    buffer 的字節大小。注意這並不是一定是內容的大小。length 表示爲 buffer 對象分配的內存大小。當緩衝區內容改變時它是不會改變的。

1 buf = new Buffer(1234);
2 
3 console.log(buf.length);
4 buf.write("some string", 0, "ascii");
5 console.log(buf.length);
6 
7 // 1234
8 // 1234

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

• targetBuffer Buffer 對象 - 複製到的 Buffer
• targetStart 數值類型，可選，默認值：0
• sourceStart 數值類型，可選，默認值：0
• sourceEnd 數值類型，可選，默認值：buffer.length

    在兩個 buffer 之間複製。源區域與目的區域能夠重疊。targetStart 和 sourceStart 默認爲 0。sourceEnd 默認爲 buffer.length。
    全部傳遞的爲 undefined/NaN 或越界的值均設置爲它們各自的默認值。
    例子：建立兩個 Buffer，而後將 buf1 從 16 字節到 19 字節複製到 buf2，buf2 開始於第 8 字節。

 1 buf1 = new Buffer(26);
 2 buf2 = new Buffer(26);
 3 
 4 for (var i = 0; i < 26; i++)｛
 5     buf1[i] = i + 97; // 97 is ASCII a
 6     buf[i] = 33; // ASCII !
 7 }
 8 
 9 buf1.copy(buf2, 8, 16, 20);
10 console.log(buf2.toString('ascii', 0, 25));
11 
12 // !!!!!!!!qrst!!!!!!!!!!!!!!

buf.slice([start], [end])

• start 數值類型，可選，默認值：0
• end 數值類型，可選，默認值：buffer.length

    返回和原來的 buffer 引用同一段內存的新 buffer，只是偏移並用 start（默認爲0）和 end（默認爲 buffer.length）索引裁剪了。負索引從 buffer 的結束開始。
    修改 slice 出來的新 buffer 將修改原始 buffer 的內存！
    例子：使用 ASCII 字母表建立一個 Buffer，建立一個切片，而後從原始 Buffer 中修改一個字節。

var buf1 = new Buffer(26);

for （var i = 0; i < 26; i++) {
    buf[i] = i + 97; //97 is ASCII a
}

var buf2 = buf1.slice(0, 3);
console.log(buf.toString('ascii', 0, buf.length));
buf1[0] = 33;
console.log(buf2.toString('ascii', 0, buf2.length));

// abc
// !bc

buf.readUInt8(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移 offset 讀取無符號八位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    示例：

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

for (ii = 0; ii < buf.length; ii++)｛
    console.log(buf.readUInt8(ii));
}

// 0x3
// 0x4
// 0x23
// 0x42

buf.readUInt16LE(offset, [noAssert])
buf.readUInt16BE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個無符號16位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    示例：

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

console.log(buf.readUInt16BE(0));
console.log(buf.readUInt16LE(0));
console.log(buf.readUInt16BE(1));
console.log(buf.readUInt16LE(1));
console.log(buf.readUInt16BE(2));
console.log(buf.readUInt16LE(2));

// 0x0304
// 0x0403
// 0x0423
// 0x2304
// 0x2342
// 0x4223

buf.readUInt32LE(offset, [noAssert])
buf.readUInt32BE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個無符號32位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    示例：

 

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

console.log(buf.readUInt32BE(0));
cosnole.log(buf.readUInt32LE(0));

// 0x03042342
// 0x42230403

buf.readInt8(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移 offset 讀取有符號八位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    工做過程和 buffer.readUInt8 同樣，除了 buffer 的內容看成成2的補碼的有符號值。

buf.readInt16LE(offset, [noAssert])
buf.readInt16BE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個有符號16位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    工做過程和 buffer.readUInt16* 同樣，除了 buffer 的內容看成成2的補碼的有符號值。

buf.readInt32LE(offset, [noAssert])
buf.readInt32BE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個有符號32位整數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    工做過程和 buffer.readUInt32* 同樣，除了 buffer 的內容看成成2的補碼的有符號值。

buf.readFloatLE(offset, [noAssert])
buf.readFloatBE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個32位浮點數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    示例：

var buf = new Buffer(4);

buf[0] = 0x00;
buf[1] = 0x00;
buf[2] = 0x80;
buf[3] = 0x3f;

console.log(buf.readFloatLE(0));

// 0x01

buf.readDoubleLE(offset, [noAssert])
buf.readDoubleBE(offset, [noAssert])

• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false
• 返回值：數值類型

    從 buffer 的指定偏移以指定的端序讀取一個64爲雙精度浮點數。
    將 noAssert 設置爲 true 可跳過 offset 的驗證。這意味着 offset 可能越過 buffer 的尾部。默認爲 false。
    示例：

var buf = new Buffer(8);

buf[0] = 0x55;
buf[1] = 0x55;
buf[2] = 0x55;
buf[3] = 0x55;
buf[4] = 0x55;
buf[5] = 0x55;
buf[6] = 0xd5;
buf[7] = 0x3f;

console.log(buf.readDoubleLE(0));

// 0.3333333333333333

buf.writeUInt8(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移寫入值 value。注意，value 必須是一個有效的無符號8位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    示例：

var buf = new Buffer(4);
buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3);

console.log(buf);

// <Buffer 03 04 23 42>

buf.writeUInt16LE(value, offset, [noAssert])
buf.writeUInt16BE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定的端序寫入值 value。注意，value 必須是一個有效的無符號16位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    示例：

var buf = new Buffer(4);
buf.writeUInt16BE(0xdead, 0);
buf.writeUInt16BE(0xbeef, 2);

console.log(buf);

buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16LE(0xbeef, 2);

console.log(buf);

// <Buffer de ad be ef>
// <Buffer ad de ef be>

buf.writeUInt32LE(value, offset, [noAssert])
buf.writeUInt32BE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定的端序寫入值 value。注意，value 必須是一個有效的無符號32位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    示例：

var buf = new Buffer(4);
buf.writeUInt32BE(0xfeedface, 0);

console.log(buf);

buf.writeUInt23LE(0xfeedface, 0);

console.log(buf);

// <Buffer fe ed fa ce>
// <Buffer ce fa ed fe>

buf.writeInt8(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移寫入值 value。注意，value 必須是一個有效的有符號8位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    工做過程和 buffer.writeUInt8 同樣，除了 value 被看成成2的補碼的有符號值寫進 buffer。

buf.writeInt16LE(value, offset, [noAssert])
buf.writeInt16BE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定端序寫入值 value。注意，value 必須是一個有效的有符號16位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    工做過程和 buffer.writeUInt16* 同樣，除了 value 被看成成2的補碼的有符號值寫進 buffer。

buf.writeInt32LE(value, offset, [noAssert])
buf.writeInt32BE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定端序寫入值 value。注意，value 必須是一個有效的有符號32位整數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    工做過程和 buffer.writeUInt32* 同樣，除了 value 被看成成2的補碼的有符號值寫進 buffer。

buf.writeFloatLE(value, offset, [noAssert])
buf.writeFloatBE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定端序寫入值 value。注意，若是 value 不是一個32位浮點數，其行爲是不肯定的。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    示例：

var buf = new Buffer(4);
buf.writeFloatBE(0xcafebabe, 0);

console.log(buf);

buf.writeFloatLE(0xcafebabe, 0);

// <Buffer 4f 4a fe bb>
// <Buffer bb fe 4a 4f>

buf.writeDoubleLE(value, offset, [noAssert])
buf.writeDoubleBE(value, offset, [noAssert])

• value 數值類型
• offset 數值類型
• noAssert 布爾值類型，可選，默認值：false

    向 buffer 的指定偏移以指定端序寫入值 value。注意，value 必須是一個64位浮點數。
    將 noAssert 設置爲 true 可跳過 value 和 offset 的驗證。這意味着 value 可能對該函數來講太大或 offset 可能越過 buffer 的尾部，致使值被悄悄地截斷。這不該該被使用除非你能確保正確性。默認爲 false。
    示例：

var buf = new Buffer(8);
buf.writeDoubleBE(0xdeadbeefcafebabe, 0);

console.log(buf);

buf.writeDoubleLE(0xdeadbeefcafebabe, 0);

console.log(buf);

// <Buffer 43 eb d5 b7 dd f9 5f d7>
// <Buffer d7 5f f9 dd b7 d5 eb 43>

buf.fill(value, [offset], [end])

• value
• offset 數值類型，可選
• end 數值類型，可選

    以指定的值填充 buffer。若是 offset（默認爲 0 ）和 end（默認爲 buffer.length ）沒有給出，將填充整個 buffer。

var b = new Buffer(50);
b.fill("h");

buffer.INSPECT_MAX_BYTES

• 數值類型，默認值：50

    當調用 buffer.inspect() 時多少字節將被返回。這能夠被用戶模塊重寫。
    注意這是 require('buffer') 返回的 buffer 模塊的屬性，不是在 Buffer 全局對象上，也不是在 buffer 實例上。

Class: SlowBuffer

    這個類主要是做爲內部使用。JavaScript 程序應該使用 Buffer 而不是 SlowBuffer。
    爲了不在服務器的生存期內常常爲小塊的內存分配不少 C++ Buffer 對象，Node 以 8Kb（8192 字節）爲一塊分配內存。若是 buffer 比這個大小還要小，那麼它將依附於一個 SlowBuffer 父對象。若是它這個大小要大，那麼 Node 將直接爲它建立一個 SlowBuffer slab。