• Node.js Video Tutorials

Node.js - 緩衝區

上一頁
下一頁

Node.js 中的緩衝區類物件用於表示固定長度的位元組序列。它儲存原始資料，類似於整數陣列，但對應於 V8 堆之外的原始記憶體分配。Node.js 中的 Buffer 類是 JavaScript Uint8Array 類的子類。儘管 Buffer 類例項是一個全域性物件，但建議透過 import 或 require 語句顯式引用該類。

在早期版本的 Node.js 中，緩衝區物件是用 new 運算子宣告的：

var buf = new Buffer(10);

也可以從給定的陣列建立一個緩衝區物件：

var buf = new Buffer([10, 20, 30, 40, 50]);

或從給定的字串：

var buf = new Buffer("Simply Easy Learning", "utf-8");

但是，現在已棄用 new 關鍵字的使用。您需要使用以下靜態方法來建立 Buffer 物件：

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates an uninitialized buffer of length 10.
const buf2 = Buffer.allocUnsafe(10);

// Creates a Buffer containing array
const buf3 = Buffer.from([1, 2, 3]);

// creates a buffer from string
const buf4 = Buffer.from('hello world', 'utf8');

靜態方法

alloc()

分配一個指定大小（以位元組為單位）的新緩衝區。

Buffer.alloc(size[, fill[, encoding]])

引數

  • size - 新緩衝區的所需長度。

  • fill - 用來預填充新緩衝區的 value。預設為 0。

  • encoding - 如果 fill 是字串，則為其編碼。預設為 'utf8'。

示例

const buf = Buffer.alloc(5);

console.log(buf);
輸出
<Buffer 00 00 00 00 00>

allocUnsafe()

建立一個指定大小（以位元組為單位）的未初始化緩衝區。

Buffer.allocUnsafe(size)

示例

const buf = Buffer.allocUnsafe(10);

console.log(buf);

buf.fill('a');

console.log(buf);
輸出
<Buffer 38 67 ff aa 32 56 00 00 08 00>
<Buffer 61 61 61 61 61 61 61 61 61 61>

from()

使用範圍在 0 – 255 之間的位元組陣列分配新的緩衝區。

示例

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf1 = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(buf1);

// Creates a new Buffer from integer array.
const buf2 = Buffer.from([10, 20, 30, 40, 50]);
console.log(buf2);
輸出
<Buffer 62 75 66 66 65 72>
<Buffer 0a 14 1e 28 32>

from()

建立一個包含字串的新緩衝區。

Buffer.from(string[, encoding])

引數

string <string> 要編碼的字串。

encoding <string> 字串的編碼。預設為 'utf8'。encoding 引數標識在將字串轉換為位元組時要使用的字元編碼。

示例

const buf1 = Buffer.from('Hello World');
console.log(buf1);
console.log(buf1.toString());
輸出
<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
Hello World

compare()

比較緩衝區物件與其他緩衝區物件。

compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])

引數

  • target - 用於比較的緩衝區。

  • targetStart - 在 target 中開始比較的偏移量。預設為 0。

  • targetEnd - 在 target 中結束比較的偏移量（不包含）。預設為 target.length。

  • sourceStart - 在源緩衝區中開始比較的偏移量。預設為 0。

  • sourceEnd - 在源緩衝區中結束比較的偏移量（不包含）。預設為 buf.length。

該函式返回一個數字，指示第一個緩衝區在排序順序中是位於第二個緩衝區物件之前、之後還是與之相同。

如果第二個與第一個相同，則返回 0

如果第二個緩衝區在排序時應該位於第一個緩衝區之前，則返回 1。

如果第二個緩衝區在排序時應該位於第一個緩衝區之後，則返回 -1。

示例

var buffer1 = Buffer.from('BALL');
var buffer2 = Buffer.from('BAT');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 +" comes before " + buffer2);
} else if(result === 0) {
   console.log(buffer1 +" is same as " + buffer2);
} else {
   console.log(buffer1 +" comes after " + buffer2);
}
輸出
BALL comes before BAT

在上面的示例中，將兩個 Buffer 物件更改為：

var buffer1 = Buffer.from('CURE');
var buffer2 = Buffer.from('CORE');
輸出
CURE comes after CORE

copy()

將資料從此緩衝區的某個區域複製到目標緩衝區的某個區域，即使目標記憶體區域與源記憶體區域重疊。

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

引數

  • target - 要複製到的緩衝區。

  • targetStart - 開始寫入的 target 中的偏移量。預設為 0。

  • sourceStart - 開始複製的 buf 中的偏移量。預設為 0。

  • sourceEnd - 停止複製的 buf 中的偏移量（不包含）。預設為 buf.length。

示例

var buffer1 = Buffer.from('Hello World');
var buffer2 = Buffer.allocUnsafe(buffer1.length);
var result = buffer1.compare(buffer2);

buffer1.copy(buffer2);
console.log("buffer2 content: " + buffer2.toString());
輸出
buffer2 content: Hello World

entries()

返回緩衝區物件內容的 [index, byte] 對的迭代器。

示例

var buf = Buffer.from('Hello World');
for (const pair of buf.entries()) {
  console.log(pair);
}
輸出
[ 0, 72 ]
[ 1, 101 ]
[ 2, 108 ]
[ 3, 108 ]
[ 4, 111 ]
[ 5, 32 ]
[ 6, 87 ]
[ 7, 111 ]
[ 8, 114 ]
[ 9, 108 ]
[ 10, 100 ]

slice()

返回一個由給定索引裁剪的新緩衝區

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

引數

  • start - 數字，可選，預設為 0

  • end - 數字，可選，預設為 buffer.length

返回值

返回一個新的緩衝區，由 start（預設為 0）和 end（預設為 buffer.length）索引進行偏移和裁剪。負索引從緩衝區的末尾開始。

示例

var buffer1 = Buffer.from('TutorialsPoint');
//slicing a buffer
var buffer2 = buffer1.slice(0,9);
console.log("buffer2 content: " + buffer2.toString());
輸出
buffer2 content: Tutorials

write()

根據指定的編碼將字串寫入緩衝區的偏移量。

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

引數

  • string - 要寫入 buf 的字串。

  • offset - 開始寫入字串之前要跳過的位元組數。預設為 0。

  • length - 要寫入的最大位元組數（寫入的位元組數不會超過 buf.length - offset）。預設為 buf.length - offset。

  • encoding - 字串的字元編碼。預設為 'utf8'。

該函式返回寫入的位元組數。

示例

const buf = Buffer.alloc(256);

const len = buf.write("Simple Easy Learning");

console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
輸出
20 bytes: Simple Easy Learning

toJSON()

返回給定緩衝區物件的 JSON 表示形式。

示例

const buf = Buffer.from("Simple Easy Learning");

var json = buf.toJSON();
console.log(json);
輸出
{
  type: 'Buffer',
  data: [
     83, 105, 109, 112, 108, 101,
     32,  69,  97, 115, 121,  32,
     76, 101,  97, 114, 110, 105,
    110, 103
  ]
}

concat()

返回一個新的 Buffer，它是所有 Buffer 例項連線的結果。

concat(list[, totalLength])

引數

  • list - 要連線的 Buffer 或 Uint8Array 例項列表。

  • totalLength - 列表中 Buffer 例項連線後的總長度。

示例

var buffer1 = Buffer.from('TutorialsPoint ');
var buffer2 = Buffer.from('Simply Easy Learning');
var buffer3 = Buffer.concat([buffer1,buffer2]);

console.log("buffer3 content: " + buffer3.toString());
輸出
buffer3 content: TutorialsPoint Simply Easy Learning

方法參考

類方法

序號 方法和描述
1

Buffer.isEncoding(encoding)

如果編碼是有效的編碼引數，則返回true，否則返回false。
2

Buffer.isBuffer(obj)

測試obj是否為Buffer。
3

Buffer.byteLength(string[, encoding])

給出字串的實際位元組長度。encoding預設為'utf8'。它與String.prototype.length不同，因為String.prototype.length返回字串中字元的個數。
4

Buffer.concat(list[, totalLength])

返回一個緩衝區，它是將列表中所有緩衝區連線在一起的結果。
5

Buffer.compare(buf1, buf2)

與buf1.compare(buf2)相同。對於排序緩衝區陣列很有用。
列印頁面
上一頁
下一頁
廣告