Node.js教程-Buffer对象

最新推荐文章于 2025-05-20 00:12:58 发布

原创最新推荐文章于 2025-05-20 00:12:58 发布 · 1.7k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#node.js

本文详细介绍了Node.js中的Buffer对象，包括其用途、特点、创建方式（如`Buffer.from()`和`Buffer.alloc()`）、编码转换、常用方法（如`compare()`、`slice()`等）以及安全注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

Buffer对象是Node用于在网络或文件系统操作等场景中处理二进制数据流。用于表示固定长度的字节序列。
一个 Buffer类似于一个整数数组，它对应了 V8 堆之外的一块原始内存。
Buffer在Node是一个全局变量，无需通过require关键字来导入其模块。

在V6.0前创建Buffer对象直接使用new关键字来创建实例，但其对内存的权限操作比较大，可直接捕获一些敏感信息，所以在V6.0之后，官方建议使用Buffer.from()接口去创建其对象

特点

Buffer 的结构与数组类型，操作方法也与数组类型
Buffer 专门用于存储二进制数据，数组不能存储二进制数据、
Buffer 存储的是二进制数据，以16进制的形式显示
Buffer 中每个元素占用一个字节，即每个元素的范围是00~ff(0~255)
Buffer 是对底层内存的直接操作，长度确定了就不能再修改

Buffer 字符编码

Buffer实例一般用于表示编码字符的序列。通过显式的字符编码，可以在 Buffer 实例与普通的字符串之间进行相互转化。
Node.js目前支持的字符编码：

ascii 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的
utf8 多字节的 Unicode 字符
utf16le 2或4个字节，小字节序编码的 Unicode 字符。支持代理对(U+10000 至 U+10FFFF)
ucs2 utf16le 的别名
base64 Base64编码
latin1 把 Buffer 编码成一字节编码的字符串的方式
binary latin1 的别名
hex 将每个字节编码为两个十六进制字符

const buf = Buffer.from('Node.js', 'ascii');

console.log(buf.toString('hex'));  // 4e6f64652e6a73
console.log(buf.toString('base64'));  // Tm9kZS5qcw==

创建 Buffer 实例

Buffer提供了多种方式来创建其实例。

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

参数说明：

size 表示实例长度
fill 表示填充值。其值可为 string、Buffer、Uint8Array、integer，默认值：0
encoding 表示编码方式。默认值:utf8。（填充值为string有效）

// 创建一个长度为 10, 且用 0 填充的 Buffer 实例
const buf1 = Buffer.alloc(10)
console.log(buf1)  // <Buffer 00 00 00 00 00 00 00 00 00 00>

   // 创建一个长度为 10, 且用 6 填充的 Buffer 实例
const buf2 = Buffer.alloc(10, 6)
console.log(buf2)  // <Buffer 06 06 06 06 06 06 06 06 06 06>

const buf3 = Buffer.alloc(10, "x")
console.log(buf3)  // <Buffer 78 78 78 78 78 78 78 78 78 78>

const buf4 = Buffer.alloc(10, "nodejs", "base64")
console.log(buf4)  // <Buffer 9e 87 5e 8e 9e 87 5e 8e 9e 87>

注意：

若指定了fill，则分配的Buffer将通过**buf.fill(fill)**进行初始化
若同时指定了fill和encoding，则则分配的Buffer将通过**buf.fill(fill，encoding)**进行初始化

Buffer.allocUnsafe(size)

返回一个指定大小的实例。其不会被初始化，可能包含敏感信息。
参数说明：

size 表示实例长度

const buf1 = Buffer.allocUnsafe(10)
// 此处输入不确定，可能包含敏感信息
console.log(buf1)  // <Buffer 00 3a 48 f3 01 00 00 dh 08 32>

// 通过 实例的 fill() 填充数据 
buf1.fill(1)
console.log(buf1)  // <Buffer 01 01 01 01 01 01 01 01 01 01>

Buffer.from(array)

通过一个字节的 array 创建一个新的 Buffer
参数说明：

array 表示一位的数组

const buf1 = Buffer.from([11, 22, 33, 44])
console.log(buf1) // <Buffer 0b 16 21 2c>

Buffer.from(buffer)

将传入的 buffer 数据拷贝到一个新建的 Buffer 实例
参数说明：

buffer 表示一个 buffer

const buf1 = Buffer.from([11, 22, 33, 44])
const buf2 = Buffer.from(buf1)
console.log(buf2)  //  <Buffer 0b 16 21 2c>

Buffer.from(string[, encoding])

创建一个包含 string 的 Buffer 实例，encoding 表示 string 的字符编码
参数说明：

string 表示一个字符串
encoding 表示字符串编码。默认值：utf8

const buf1 = Buffer.from("中国")
console.log(buf1)  // <Buffer e4 b8 ad e5 9b bd>

const buf2 = Buffer.from("中国", "utf8")
console.log(buf2)  // <Buffer e4 b8 ad e5 9b bd>

const buf3 = Buffer.from("中国", "latin1")
console.log(buf3)  // <Buffer 2d fd>

Buffer.from(arrayBuffer[, byteOffet[, length]])

创建一个与 arrayBuffer 的视图，而不会复制底层内存，共享同一块内存。
参数说明：

arrayBuffer 表示 | ArrayBuffer 或 SharedArrayBuffer 或 TypedArray 的 .buffer 属性
byteOffet 开始拷贝的索引。默认值：0
length 拷贝的字节数。默认值：arrayBuffer.length - byteOffet

const arr = new Uint8Array(2)
arr[0] = 10
arr[1] = 20

const buf1 = Buffer.from(arr.buffer)
console.log(buf1)  // <Buffer 0a 14>

arr[0] = 30
console.log(buf1)  // <Buffer 1e 14>

Buffer.from(object[, offsetOrEncoding[, length]])

创建一个将对象转为 Buffer 实例
参数说明：

object 表示一个支持 Symbol.toPrimitive或 valueOf() 的对象
offsetOrEncoding 表示字节偏移量或编码。取决于**object.valueOf()或object[Symbol.toPrimitive]**的值
length 表示长度值。取决于 object.valueOf() 或 object[Symbol.toPrimitive] 的值

const buf1 = Buffer.from(new String("Hello Node"))
console.log(buf1)  // <Buffer 48 65 6c 6c 6f 20 4e 6f 64 65>

Buffer.concat(list[, totalLength])

返回一个合并了 list 中所有 Buffer实例的新建 Buffer
参数说明：

list 表示待合并的Buffer或Uint8Array实例的数组
totalLength 表示合并list中Buffer实例的总长度

const buf1 = Buffer.alloc(4, 1)
const buf2 = Buffer.alloc(6, 2)
const buf3 = Buffer.alloc(8, 3)

const totalLength = buf1.length + buf2.length + buf3.length

const buf = Buffer.concat([buf1, buf2, buf3], totalLength)
console.log(buf)  // <Buffer 01 01 01 01 02 02 02 02 02 02 03 03 03 03 03 03 03 03>

Buffer.copyBytesFrom(view[, offset[, length]])

将view的底层内存复制到新的 Buffer 实例中。 新增于: v19.8.0
参数说明：

view 表示待复制的 TypeArray
offset 表示view中的起始偏移量。默认值：0
length 表示view中要复制的元素数。默认值：view.length - offset

const u16 = new Uint16Array([0, 0xbbbb, 0xffff]);

const buf = Buffer.copyBytesFrom(u16)
const buf1 = Buffer.copyBytesFrom(u16, 1)

u16[1] = 0;

console.log(buf.length); // 6
console.log(buf)  // <Buffer 00 00 bb bb ff ff>

console.log(buf1.length); // 4
console.log(buf1)  // <Buffer bb bb ff ff>

常见方法

静态方法

Buffer.byteLength(string[, encoding])

返回一个字符串的实际字节长度。(与 string.prototype.length不同，其返回的是字符串的字符数)
参数说明：

string 表示一个字符串
encoding 表示编码方式

const str1 = "中国"
console.log(str1.length)  // 2
console.log(Buffer.byteLength(str1, "utf8"))  // 6

const str2 = "China"
console.log(str2.length)  // 5
console.log(Buffer.byteLength(str2, "utf8"))  // 5

Buffer.compare(buf1, buf2)

返回两个buf比较的值。通常用于 Buffer实例的排序，相当于 buf1.compare(buf2)

const buf1 = Buffer.from("123")
const buf2 = Buffer.from("456");
console.log(Buffer.compare(buf1, buf2))  // -1

Buffer.isBuffer(obj)

判断 obj 是否为 Buffer

console.log(Buffer.isBuffer(Buffer.from("abc")))  // true
console.log(Buffer.isBuffer("abc"))  // false
console.log(Buffer.isBuffer([]))  // false

Buffer.isEncoding(encoding)

判断encoding是支持的字符编码的名称。

console.log(Buffer.isEncoding(""))  // false
console.log(Buffer.isEncoding("utf8"))  // true
console.log(Buffer.isEncoding("ascii"))  // true

实例方法

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

使用指定的编码解码buf。也称为从缓冲区中读取数据
参数说明：

encoding 表示编码方式。默认值：utf8
start 表示开始读取的偏移量。默认值：0
end 表示结束读取的偏移量。默认值：buf.length

const buf = Buffer.from("abcdefg")
console.log(buf.toString())  // abcdefg
console.log(buf.toString("base64"))  // YWJjZGVmZw==

buf.toJSON()

返回buf的JSON格式。当字符串化一个Buffer实例时，**JSON.stringify()**会隐式地调用该函数。

const buf = Buffer.from("abcdefg")
/**
{
  type: 'Buffer',      
  data: [97,  98,  99, 100, 101, 102, 103]      
}
*/
console.log(buf.toJSON())

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

返回 buf与target的比较值(对比是基于各自的字节序列)。buf在排序上是否排在target之前、之后或相同。
参数说明：

target 表示待比较的 Buffer 或 Uint8Array
targetStart 表示 target 开始对比的偏移量。默认值：0
targetEnd 表示 target 结束对比的偏移量。默认值：target.length
sourceStart 表示 buf 开始对比的偏移量。默认值：0
sourceEnd 表示 buf 结束对比的偏移量。默认值：buf.length

const buf1 = Buffer.from("abc")
const buf2 = Buffer.from("ABC")
console.log(buf1.compare(buf2))  // 1

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

拷贝buf中数据到target中。
参数说明：

target 表示待拷贝进的 Buffer 或 Uint8Array
targetStart 表示 target 开始拷贝进的偏移量。默认值：0
sourceStart 表示 buf 开始拷贝出的偏移量。默认值：0
sourceEnd 表示 buf 结束拷贝出的偏移量。默认值：buf.length

const buf1 = Buffer.from("1234567890")
console.log(buf1)  // <Buffer 31 32 33 34 35 36 37 38 39 30>

const buf2 = Buffer.alloc(5)

buf1.copy(buf2, 1, 2)
console.log(buf2)  // <Buffer 00 33 34 35 36>

buf.equals(otherBuffer)

若buf与otherBuffer具有完全相同的字节，则返回 true，否则返回 false。

const buf1 = Buffer.from("abc")
console.log(buf1)  // <Buffer 61 62 63>

const buf2 = Buffer.from("ABC")
console.log(buf2)  // <Buffer 41 42 43>

const buf3 = Buffer.from("abc", "hex")
console.log(buf3)  // <Buffer ab> 

console.log(buf1.equals(buf2))  // false
console.log(buf1.equals(buf3))  // false

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

使用value填充buf
参数说明：

value 表示待填充的值
offset 表示开始填充的偏移量。默认值：0
end 表示结束填充的偏移量。默认值：buf.length
encoding 表示填充的编码方式。默认值：utf8

const buf = Buffer.alloc(3)

buf.fill(1)  
console.log(buf)  // <Buffer 01 01 01>

buf.fill(2, 2)
console.log(buf)  // <Buffer 01 01 02>

buf.keys()

返回一个包含 buf 键名(索引)的迭代器

const buf = Buffer.from("1234567890")

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
for (const index of buf.keys()) {
  console.log(index)
}

buf.values()

返回一个包含buf键值的迭代器

const buf = Buffer.from("1234567890")

// 49
// 50
// 51
// 52
// 53
// 54
// 55
// 56
// 57
// 48 
for (const value of buf.values()) {
  console.log(value)
}

buf.entries()

从 buf的内容中，创建并返回一个**[index, byte]**迭代器。

const buf = Buffer.from("1234567890")

// [ 0, 49 ]
// [ 1, 50 ]
// [ 2, 51 ]
// [ 3, 52 ]
// [ 4, 53 ]
// [ 5, 54 ]
// [ 6, 55 ]
// [ 7, 56 ]
// [ 8, 57 ]
// [ 9, 48 ]
for (const data of buf.entries()) {
  console.log(data)
}

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

返回buf中value首次出现的索引值
参数说明：

value 表示待搜索的值
byteOffset 表示开始搜索的偏移量。默认值：0
encoding 表示字符串的编码方式。默认值：utf8

const buf = Buffer.from("abcdefg")
console.log(buf.indexOf("c"))    // 2
console.log(buf.indexOf("c", 2))  // 2
console.log(buf.indexOf("c", 5))  // -1

buf.lastIndexOf(value[,byteOffset][, encoding])

返回buf中value最后一次出现的索引值
参数说明：

value 表示待搜索的值
byteOffset 表示开始搜索的偏移量。默认值：buf.length - 1
encoding 表示字符串的编码方式。默认值：utf8

const buf = Buffer.from("abcdefg")
console.log(buf.lastIndexOf("c"))    // 2
console.log(buf.lastIndexOf("c", 2))  // 2
console.log(buf.lastIndexOf("c", 5))  // 2

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

从start到end裁剪缓冲区，返回一个新的缓冲区，它和旧缓冲区指向同一块内存。
参数说明：

start 表示裁剪开始的索引值。默认值：0
end 表示裁剪结束的索引值。默认值：buf.length

const buf = Buffer.from("abcdefg")
console.log(buf)  // <Buffer 61 62 63 64 65 66 67>
console.log(buf.slice(2, 5))  // <Buffer 63 64 65>

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

根据字符编码，将字符串写入缓冲区中指定的位置
参数说明：

string 写入缓冲区的数据
offset 缓冲区开始写入的起始索引值。默认值：0
length 写入缓冲区的字节数。默认值：buf.length
encoding 写入的编码格式

const buf = Buffer.alloc(100)
buf.write("Hello Node.js")
console.log(buf)  // <Buffer 48 65 6c 6c 6f 20 4e 6f 64 65 2e 6a 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ... 50 more bytes>

buf.write("Hello Node.js", 0, "base64")
console.log(buf)  // <Buffer 1d e9 65 a0 da 1d 7a 3b 64 65 2e 6a 73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ... 50 more bytes>