Buffer · io.js API 中文文檔

### 穩定度: 2 - 穩定純粹的`JavaScript`是Unicode友好的，但是不能很好地處理二進制數據。當處理TCP流或者文件流時，操作八進制流是必要的。`io.js`提供了多種策略來操作，創建和使用八進制流。原始的數據被存儲在`Buffer`類的實例中，一個`Buffer`類似于一個整數數組但是使用了V8堆之外的內存分配。一個`Buffer`不能被改變大小。 `Buffer`類是全局的，所以它是少數的不用`require('buffer')`就能使用的對象之一。 `Buffer`和`JavaScript`字符串對象之間的轉換需要指定一個明確地編碼方法。以下是一些不同的字符串編碼。 'ascii' - 僅供7位的ASCII數據使用，這個編碼方法非常的快速，而且會剝離過高的位（如果有設置）。 'utf8' - 多字節編碼的字符。許多web頁面和一些其他文檔都使用UTF-8編碼。 'utf16le' - 2或4個字節，`little endian`編碼字符。支持(U+10000 到 U+10FFFF)的代理對。 'ucs2' - 'utf16le'的別名。 'base64' - Base64 字符串編碼。 'binary' - 一種通過使用每個字符的前八位來將二進制數據解碼為字符串的方式。這個編碼方法已經不被推薦使用，在處理`Buffer`對象時應避免使用它，這個編碼將會在`io.js`的未來版本中移除。 'hex' - 把每個字節編碼成2個十六進制字符。從一個`Buffer`創建一個類型數組(typed array)遵循以下的說明： 1，`Buffer`的內存是被復制的，不是共享的。 2，`Buffer`的內存被解釋當做一個數組，而不是一個字節數組(byte array)。換言之，`new Uint32Array(new Buffer([1,2,3,4]))`創建了一個4個元素（[1,2,3,4]）的`Uint32Array`,不是一個只有一個元素（[0x1020304] 或 [0x4030201]）的`Uint32Array`。注意： Node.js v0.8 只是簡單得在`array.buffer`中保留了`buffer`的引用，而不是復制一份。 #### Class: Buffer Buffer類是一個全局類用于直接處理二進制數據。它的實例可以被多種途徑構建。 #### new Buffer(size) - size Number 分配一個大小為指定`size`的八位字節的新`buffer`。注意，`size`不能超過kMaxLength，否則一個`RangeError`將會被拋出。 #### new Buffer(array) - array Array 使用一個八進制數組分配一個新的`buffer`。 #### new Buffer(buffer) - buffer Buffer 將傳遞的`buffer`復制進一個新的Buffer實例。 #### new Buffer(str[, encoding]) - str String - 傳入buffer的字符串 - encoding String - 可選，使用的編碼根據給定的`str`創建一個新的`buffer`，編碼默認是UTF-8。 #### Class Method: Buffer.isEncoding(encoding) - encoding String 將要被測試的編碼，返回`true`若此編碼是合法的，否則返回`false`。 #### Class Method: Buffer.isBuffer(obj) - obj Object - Return: Boolean 測試`obj`是否為一個`buffer`。 #### Class Method: Buffer.byteLength(string[, encoding]) - string String - encoding String, 可選，默認： 'utf8' - Return: Number 給出`string`的實際字節長度。編碼默認為UTF-8。這與`String.prototype.length`不同，因為`String.prototype.length`只返回字符串中字符的數量。例子: ~~~ str = '\u00bd + \u00bc = \u00be'; console.log(str + ": " + str.length + " characters, " + Buffer.byteLength(str, 'utf8') + " bytes"); // ? + ? = ?: 9 characters, 12 bytes ~~~ #### Class Method: Buffer.concat(list[, totalLength]) - list Array 需要被連接的Buffer對象 - totalLength Number 將要被連接的buffers的 - Returns 連接完畢的buffer 若`list`為空，或`totalLength`為0，那么將返回一個長度為0的buffer。若`list`只有一個元素，那么這個元素將被返回。若`list`有超過一個元素，那么將創建一個新的Buffer實例。如果`totalLength`沒有被提供，那么將會從`list`中計算讀取。但是，這增加了函數的一個額外的循環，所以如果直接長度那么性能會更好。 #### Class Method: Buffer.compare(buf1, buf2) - buf1 Buffer - buf2 Buffer與buf1.compare(buf2)相同. 對于排序一個Buffers的數組非常有用: ~~~ var arr = [Buffer('1234'), Buffer('0123')]; arr.sort(Buffer.compare); ~~~ #### buf.length - Return Number 這個buffer的字節長度。注意這不一定是這個buffer中的內容長度。它是這個buffer對象所分配內存大小，并不會隨著buffer的內容的改變而改變 ~~~ buf = new Buffer(1234); console.log(buf.length); buf.write("some string", 0, "ascii"); console.log(buf.length); // 1234 // 1234 ~~~ 雖然`buffer`的`length`屬性并不是不可變的，改變`length`屬性的值可能會使之變成`undefined`或引起一些不一致的行為。希望去改變`buffer`的`length`的應用應當把它視作一個只讀的值，并且使用`buf.slice`來創建一個新的`buffer`。 ~~~ buf = new Buffer(10); buf.write("abcdefghj", 0, "ascii"); console.log(buf.length); // 10 buf = buf.slice(0,5); console.log(buf.length); // 5 ~~~ #### buf.write(string[, offset][, length][, encoding]) - string String 準備被寫入buffer的數據 - offset Number 可選，默認為0 - length Number 可選，默認為 `buffer.length - offset` - encoding String 可選，默認為 'utf8' 從指定的偏移位置(offset)使用給定的編碼向buffer中寫入字符串，偏移位置默認為0，編碼默認為UTF8。長度為將要寫入的字符串的字節大小。返回被寫入的八進制流的大小。如果buffer沒有足夠的空間寫入整個字符串，那么它將只會寫入一部分。`length`參數默認為`buffer.length - offset`，這個方法將不會只寫入字符的一部分。 ~~~ buf = new Buffer(256); len = buf.write('\u00bd + \u00bc = \u00be', 0); console.log(len + " bytes: " + buf.toString('utf8', 0, len)); ~~~ #### buf.writeUIntLE(value, offset, byteLength[, noAssert]) #### buf.writeUIntBE(value, offset, byteLength[, noAssert]) #### buf.writeIntLE(value, offset, byteLength[, noAssert]) #### buf.writeIntBE(value, offset, byteLength[, noAssert]) - value {Number} 將要被寫入buffer的字節 - offset {Number} `0 <= offset <= buf.length` - byteLength {Number} `0 < byteLength <= 6` - noAssert {Boolean} 默認為`false` - Return: {Number} 根據指定的偏移位置(offset)和`byteLength`將`value`寫入buffer。最高支持48位的精確度。例子： ~~~ var b = new Buffer(6); b.writeUIntBE(0x1234567890ab, 0, 6); // <Buffer 12 34 56 78 90 ab> ~~~ 將`noAssert`設置為true將會跳過`value`和`offset`的檢驗，默認為`false`。 #### buf.readUIntLE(offset, byteLength[, noAssert]) #### buf.readUIntBE(offset, byteLength[, noAssert]) #### buf.readIntLE(offset, byteLength[, noAssert]) #### buf.readIntBE(offset, byteLength[, noAssert]) - offset {Number} `0 <= offset <= buf.length` - byteLength {Number} `0 < byteLength <= 6` - noAssert {Boolean} 默認為`false` - Return: {Number} 一個普遍的用來作數值讀取的方法，最高支持48位的精確度。例子： ~~~ var b = new Buffer(6); b.writeUint16LE(0x90ab, 0); b.writeUInt32LE(0x12345678, 2); b.readUIntLE(0, 6).toString(16); // Specify 6 bytes (48 bits) // output: '1234567890ab' ~~~ 將`noAssert`設置為true將會跳過`value`和`offset`的檢驗，這意味著`offset`將可能超過buffer的結束位置，默認為`false`。 #### buf.toString([encoding][, start][, end]) - encoding String, 可選，默認為 'utf8' - start Number, 可選，默認為 0 - end Number, 可選默認為 `buffer.length` 從編碼的buffer數據中使用指定的編碼解碼并返回結果字符串。如果`encoding`為`undefined`或`null`，那么`encoding`將默認為UTF8。`start`和`end`參數默認為`0`和`buffer.length`。 ~~~ buf = new Buffer(26); for (var i = 0 ; i < 26 ; i++) { buf[i] = i + 97; // 97 is ASCII a } buf.toString('ascii'); // outputs: abcdefghijklmnopqrstuvwxyz buf.toString('ascii',0,5); // outputs: abcde buf.toString('utf8',0,5); // outputs: abcde buf.toString(undefined,0,5); // encoding defaults to 'utf8', outputs abcde ~~~ #### buf.toJSON() 返回一個Buffer實例的JSON形式。`JSON.stringify`被隱式得調用當轉換Buffer實例時。例子: ~~~ var buf = new Buffer('test'); var json = JSON.stringify(buf); console.log(json); // '{"type":"Buffer","data":[116,101,115,116]}' var copy = JSON.parse(json, function(key, value) { return value && value.type === 'Buffer' ? new Buffer(value.data) : value; }); console.log(copy); // <Buffer 74 65 73 74> ~~~ #### buf[index] 獲取或設置指定位置的八位字節。這個值是指單個字節，所有合法范圍在`0x00`到`0xFF` 或 `0` 到 `255`。例子：復制一個ASCII字符串到一個buffer，一次一個字節： ~~~ str = "io.js"; buf = new Buffer(str.length); for (var i = 0; i < str.length ; i++) { buf[i] = str.charCodeAt(i); } console.log(buf); // io.js ~~~ #### buf.equals(otherBuffer) - otherBuffer Buffer 返回一個布爾值表示是否`buf`與`otherBuffer`具有相同的字節。 #### buf.compare(otherBuffer) - otherBuffer Buffer 返回一個數字表示在排序上`buf`在`otherBuffer`之前，之后或相同。 #### buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd]) - targetBuffer Buffer 將要進行復制的Buffer - targetStart Number 可選，默認為 0 - sourceStart Number 可選，默認為 0 - sourceEnd Number 可選，默認為 `buffer.length` 從`buf`中的指定范圍復制數據到`targetBuffer`中的指定范圍，它們是可以重疊的。例子：創建兩個Buffer，然后復制buf1的第16字節到19字節到buf2，buf2的偏移位置從第8字節開始： ~~~ buf1 = new Buffer(26); buf2 = new Buffer(26); for (var i = 0 ; i < 26 ; i++) { buf1[i] = i + 97; // 97 is ASCII a buf2[i] = 33; // ASCII ! } buf1.copy(buf2, 8, 16, 20); console.log(buf2.toString('ascii', 0, 25)); // !!!!!!!!qrst!!!!!!!!!!!!! ~~~ 例子：創建一個單獨的Buffer，然后復制數據到自身的一個重疊的范圍。 ~~~ buf = new Buffer(26); for (var i = 0 ; i < 26 ; i++) { buf[i] = i + 97; // 97 is ASCII a } buf.copy(buf, 0, 4, 10); console.log(buf.toString()); // efghijghijklmnopqrstuvwxyz ~~~ #### buf.slice([start][, end]) - start Number 可選，默認為 0 - end Number 可選，默認為 `buffer.length` - 返回一個和舊的buffer引用了相同內存的新的buffer，但是被`start`和`end`參數所偏移和裁剪。修改這個新的buffer的切片，也會改變內存中原來的buffer。例子：創建一個ASCII字母的Buffer，然后對其進行`slice`，然后修改源Buffer上的一個字節： ~~~ var buf1 = new Buffer(26); for (var i = 0 ; i < 26 ; i++) { buf1[i] = i + 97; // 97 is ASCII a } var buf2 = buf1.slice(0, 3); console.log(buf2.toString('ascii', 0, buf2.length)); buf1[0] = 33; console.log(buf2.toString('ascii', 0, buf2.length)); // abc // !bc ~~~ #### buf.indexOf(value[, byteOffset]) - value String Buffer或Number - byteOffset Number 可選，默認為 0 - Return: Number 行為和Array.indexOf()相似。接受一個字符串，Buffer或數字。字符串被解釋為UTF8編碼，Buffer將使用整個buffer，所以如果要比較部分的Buffer請使用`Buffer.slice()`，數字的范圍需在0到255之間。 #### buf.readUInt8(offset[, noAssert]) - offset Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中讀取一個無符號8位整數。將`noAssert`設置為true將會跳過`value`和`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 Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個無符號16位整數。將`noAssert`設置為true將會跳過`value`和`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 Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個無符號32位整數。將`noAssert`設置為true將會跳過`value`和`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)); console.log(buf.readUInt32LE(0)); // 0x03042342 // 0x42230403 ~~~ #### buf.readInt8(offset[, noAssert]) - offset Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中讀取一個有符號8位整數。將`noAssert`設置為true將會跳過`value`和`offset`的檢驗，這意味著`offset`將可能超過buffer的結束位置，默認為`false`。運作和`buffer.readUInt8`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.readInt16LE(offset[, noAssert]) #### buf.readInt16BE(offset[, noAssert]) - offset Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個有符號16位整數。將`noAssert`設置為true將會跳過`value`和`offset`的檢驗，這意味著`offset`將可能超過buffer的結束位置，默認為`false`。運作和`buffer.readUInt16`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.readInt32LE(offset[, noAssert]) #### buf.readInt32BE(offset[, noAssert]) - offset Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個有符號32位整數。將`noAssert`設置為true將會跳過`value`和`offset`的檢驗，這意味著`offset`將可能超過buffer的結束位置，默認為`false`。運作和`buffer.readUInt32`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.readFloatLE(offset[, noAssert]) #### buf.readFloatBE(offset[, noAssert]) - offset Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個32位浮點數。將`noAssert`設置為true將會跳過`value`和`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 Number - noAssert Boolean 可選，默認為 `false` - Return: Number 根據制定偏移量從buffer中根據特定的`endian`字節序讀取一個64位雙精度數。將`noAssert`設置為true將會跳過`value`和`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 Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置寫入`value`。注意，`value`必須是一個合法的無符號8位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`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 Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的無符號16位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`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 Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的無符號32位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`false`。例子： ~~~ var buf = new Buffer(4); buf.writeUInt32BE(0xfeedface, 0); console.log(buf); buf.writeUInt32LE(0xfeedface, 0); console.log(buf); // <Buffer fe ed fa ce> // <Buffer ce fa ed fe> ~~~ #### buf.writeInt8(value, offset[, noAssert]) - value Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置中寫入`value`。注意，`value`必須是一個合法的無符號32位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`false`。運作和`buffer.writeUInt8`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.writeInt16LE(value, offset[, noAssert]) #### buf.writeInt16BE(value, offset[, noAssert]) - value Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的有符號16位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`false`。運作和`buffer.writeUInt16`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.writeInt32LE(value, offset[, noAssert]) #### buf.writeInt32BE(value, offset[, noAssert]) - value Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的有符號32位整形數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`false`。運作和`buffer.writeUInt32`相同，除非buffer內容中有包含了作為2的補碼的有符號值。 #### buf.writeFloatLE(value, offset[, noAssert]) #### buf.writeFloatBE(value, offset[, noAssert]) - value Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的32位浮點數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`false`。例子： ~~~ var buf = new Buffer(4); buf.writeFloatBE(0xcafebabe, 0); console.log(buf); buf.writeFloatLE(0xcafebabe, 0); console.log(buf); // <Buffer 4f 4a fe bb> // <Buffer bb fe 4a 4f> ~~~ #### buf.writeDoubleLE(value, offset[, noAssert]) #### buf.writeDoubleBE(value, offset[, noAssert]) - value Number - offset Number - noAssert Boolean 可選，默認為 `false` 向`buffer`的指定偏移位置根據特定的`endian`字節序寫入`value`。注意，`value`必須是一個合法的64位雙精度數。將`noAssert`設置為`true`將跳過`value`和`offset`的驗證。這意味著`value`可能會過大，或者`offset`超過`buffer`的末尾導致`value`被丟棄，這個參數除非你十分有把握否則你不應去使用它，默認為`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 Number 可選 - end Number 可選使用指定的`value`填充buffer。如果`offset`（默認為0）和`end`（默認為`buffer.length`）沒有指定，將會填充整個buffer。 ~~~ var b = new Buffer(50); b.fill("h"); ~~~ #### buffer.values() 創建一個buffer內的值（bytes）的迭代器。這個函數會被自動調用當buffer被用于`for..of`語句中時。 #### buffer.keys() 創建一個buffer的索引的迭代器。 #### buffer.entries() 創建一個[index, byte]數組迭代器。 #### buffer.INSPECT_MAX_BYTES Number 默認值： 50 表示有多少字節會被返回當調用`buffer.inspect()`時。它可以被用戶的模塊所覆蓋。注意這是一個由`require('buffer')`返回的`buffer模塊`的屬性，并不是全局`Buffer`對象或buffer實例的。 ### ES6 迭代器 `Buffers`可以被ES6的`for..of`語法迭代： ~~~ var buf = new Buffer([1, 2, 3]); for (var b of buf) console.log(b) // 1 // 2 // 3 ~~~ 另外的，`buffer.values()`，`buffer.keys()`和`buffer.entries()`方法都可以被用來創建迭代器。 #### Class: SlowBuffer 返回一個不被池管理的`Buffer`。為了避免創建許多單個的被分配內存的小Buffer的垃圾回收開銷。默認得，分配小于4KB的空間將會被從一個更大的被分配好內存的對象（allocated object）中切片(sliced)得到。這個方法改進了性能以及內存占用，因為V8的垃圾回收機制不再需要追蹤和清理許多的小對象。當開發者需要將池中一小塊數據保留不確定的一段時間，較為妥當的辦法是用 `SlowBuffer`創建一個不被池管理的`Buffer`實例并將相應數據拷貝出來。 ~~~ // need to keep around a few small chunks of memory var store = []; socket.on('readable', function() { var data = socket.read(); // allocate for retained data var sb = new SlowBuffer(10); // copy the data into the new allocation data.copy(sb, 0, 0, 10); store.push(sb); }); ~~~ 請謹慎使用，僅作為開發者察覺到在應用中有過度的內存保留時的最后手段。