【Node.js】Buffer 深度解析：从核心概念，彻底搞懂这个“字节工具人”

1
// v0.x的写法，现在会报错
2
const buf = new Buffer(10) // 手动分配10字节内存
3
buf.write('hello')
4
console.log(buf.toString()) // "hello"
5
// 但如果没手动释放，内存会泄漏

1
// Buffer的构造函数是工厂模式，最终返回FastBuffer
2
function Buffer(arg, encodingOrOffset, length) {
3
  showFlaggedDeprecation() // 提示弃用new Buffer()
4
  if (typeof arg === 'number') {
5
    return Buffer.alloc(arg) // 用alloc代替new Buffer(size)
6
  }
7
  return Buffer.from(arg, encodingOrOffset, length)
8
}
9

10
// FastBuffer继承自Uint8Array，加了Buffer的工具方法
11
class FastBuffer extends Uint8Array {
12
  constructor(bufferOrLength, byteOffset, length) {
13
    super(bufferOrLength, byteOffset, length)
14
  }
15
}
16

17
// 让instanceof Buffer返回true（表面功夫）
18
FastBuffer.prototype.constructor = Buffer
19
Buffer.prototype = FastBuffer.prototype
20

21
// 验证：Buffer其实是Uint8Array的子类
22
const buf = Buffer.from('hello')
23
console.log(buf instanceof Uint8Array) // true（本质）
24
console.log(buf instanceof Buffer) // true（表面）
25
console.log(buf.buffer) // 背后的ArrayBuffer（8KB池化内存）

1
// 1. 分配一个指定大小的空白 Buffer（推荐，最安全）
2
// 分配 10 个字节，默认会用 0 填充
3
const buf1 = Buffer.alloc(10)
4
console.log(buf1) // <Buffer 00 00 00 00 00 00 00 00 00 00>
5

6
// 2. 分配一个未初始化的 Buffer（速度更快，但可能包含旧内存数据）
7
// 性能更好，但你必须确保之后会完全填充它
8
const buf2 = Buffer.allocUnsafe(10)
9
console.log(buf2) // <Buffer 00 00 00 00 00 00 00 00 00 00> (但内容不确定)
10

11
// 3. 从数据创建 Buffer（最常用）
12
// 从一个字符串创建，可以指定编码，默认为 'utf8'
13
const buf3 = Buffer.from('Hello Node.js')
14
console.log(buf3) // <Buffer 48 65 6c 6c 6f 20 4e 6f 64 65 2e 6a 73>
15
console.log(buf3.toString()) // 'Hello Node.js' (转回字符串)
16

17
// 从一个数组创建
18
const buf4 = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]) // 十六进制数组
19
console.log(buf4.toString()) // 'Hello'
20

21
// 从另一个 Buffer 创建
22
const buf5 = Buffer.from(buf3)

1
const buf = Buffer.from('Hello')
2

3
// 读取字节 (返回十进制数字)
4
console.log(buf[0]) // 72 -> 'H' 的 ASCII 码
5
console.log(buf[1]) // 101 -> 'e' 的 ASCII 码
6

7
// 写入/修改字节
8
buf[0] = 74 // 74 是 'J' 的 ASCII 码
9
console.log(buf.toString()) // 'Jello' (证明了Buffer是可变的！)
10

11
// 检查 Buffer 长度（字节数）
12
console.log(buf.length) // 5
13

14
// 遍历 Buffer
15
for (const byte of buf) {
16
  console.log(byte) // 74, 101, 108, 108, 111
17
}

1
const buf = Buffer.from('你好，世界！', 'utf8') // 用 UTF-8 编码创建
2

3
// 转换为其他格式的字符串
4
console.log(buf.toString('hex')) // e4bda0e5a5bdefbc8ce4b896e7958c21 (十六进制表示)
5
console.log(buf.toString('base64')) // 5L2g5aW95LqG5LiW5LuLIQ== (Base64编码，常用于数据传输)
6

7
// 从其他格式解码
8
const hexBuf = Buffer.from('e4bda0e5a5bd', 'hex')
9
console.log(hexBuf.toString('utf8')) // '你好'

1
const fs = require('fs')
2

3
// 读取文件时，如果不指定编码，返回的就是一个 Buffer
4
fs.readFile('example.jpg', (err, data) => {
5
  // data 是一个 Buffer
6
  if (err) throw err
7

8
  console.log(`文件大小: ${data.length} 字节`)
9
  // 我们可以直接操作这个图片的二进制数据...
10
  // 例如，将其写入另一个文件
11
  fs.writeFile('copy-of-example.jpg', data, (err) => {
12
    if (err) throw err
13
    console.log('图片复制完成！')
14
  })
15
})
16

17
// 指定 'base64' 编码读取，得到Base64字符串
18
fs.readFile('example.jpg', 'base64', (err, data) => {
19
  // data 现在是字符串，可以直接嵌入到 HTML 的 img 标签中
20
  // <img src="data:image/jpeg;base64,这里就是data变量内容">
21
})

1
const http = require('http')
2
const fs = require('fs')
3

4
http
5
  .createServer((req, res) => {
6
    // 从磁盘读取一张图片（得到Buffer）
7
    fs.readFile('my-image.png', (err, imageBuffer) => {
8
      if (err) {
9
        res.writeHead(404)
10
        res.end('File not found')
11
        return
12
      }
13
      // 设置正确的 MIME 类型，并将 Buffer 直接作为响应体发送
14
      res.writeHead(200, { 'Content-Type': 'image/png' })
15
      res.end(imageBuffer) // 网络传输的本质就是传输二进制数据（Buffer）
16
    })
17
  })
18
  .listen(3000)

1
// 1. 字符串与Buffer互转
2
const str = 'Hello World'
3
const bufFromStr = Buffer.from(str, 'utf8')
4
const backToStr = bufFromStr.toString('utf8')
5

6
// 2. 拼接多个Buffer（例如处理分段的网络数据）
7
const buf1 = Buffer.from('Hello ')
8
const buf2 = Buffer.from('World')
9
const combinedBuf = Buffer.concat([buf1, buf2])
10
console.log(combinedBuf.toString()) // 'Hello World'
11

12
// 3. 比较两个Buffer是否相同
13
const bufA = Buffer.from('ABC')
14
const bufB = Buffer.from('ABC')
15
console.log(Buffer.compare(bufA, bufB) === 0) // true
16
console.log(bufA.equals(bufB)) // true (另一种方法)

1
const WebSocket = require('ws')
2
const wss = new WebSocket.Server({ port: 8080 })
3

4
wss.on('connection', (ws) => {
5
  ws.on('message', (data) => {
6
    if (data instanceof ArrayBuffer) {
7
      // 转成Buffer（复用ArrayBuffer的内存，不池化）
8
      const buf = Buffer.from(data)
9
      // 解析二进制消息（比如protobuf）
10
      const user = User.decode(buf)
11
      console.log('Received user:', user)
12
    }
13
  })
14
})

1
const dubbo = require('dubbo2.js')
2

3
// 调用Dubbo接口（返回类数组）
4
const result = await dubbo.invoke('com.xxx.UserService.getUser', [123])
5
// result是类数组：{ type: 'Buffer', data: [0x01, 0x02, 0x03, ...] }
6

7
// 转成Buffer（池化分配）
8
const buf = Buffer.from(result.data)
9
// 解析为User对象
10
const user = User.decode(buf)
11
console.log('User:', user)

1
const express = require('express')
2
const app = express()
3
const fs = require('fs/promises')
4

5
// 处理文件上传（分块）
6
app.post('/api/upload', async (req, res) => {
7
  const chunks = [] // 存所有chunk的Buffer
8
  let totalLength = 0
9

10
  // 监听data事件，收集chunk
11
  req.on('data', (chunk) => {
12
    chunks.push(chunk) // chunk是Buffer（小Buffer，池化）
13
    totalLength += chunk.length
14
  })
15

16
  // 监听end事件，拼接chunk
17
  req.on('end', async () => {
18
    // 拼接所有chunk（池化分配大Buffer）
19
    const fileBuf = Buffer.concat(chunks, totalLength)
20
    // 写入文件
21
    await fs.writeFile('uploaded-file.txt', fileBuf)
22
    // 响应客户端
23
    res.send('File uploaded!')
24
    // 用完后清除内存
25
    fileBuf.fill(0)
26
  })
27
})
28

29
app.listen(3000)

1
let poolSize // 当前池的大小（默认8192）
2
let poolOffset // 当前池的偏移量（已用多少字节）
3
let allocPool // 当前池的ArrayBuffer（8KB）
4

5
function createPool() {
6
  poolSize = Buffer.poolSize // 8192
7
  allocPool = createUnsafeBuffer(poolSize).buffer // 创建8KB的ArrayBuffer
8
  markAsUntransferable(allocPool) // 禁止转移ArrayBuffer的所有权
9
  poolOffset = 0 // 初始偏移量为0（从池的开头开始分配）
10
}
11

12
// 启动时创建第一个池
13
createPool()

1
const Koa = require('koa')
2
const app = new Koa()
3

4
// 处理POST请求体（小数据，用池化提升效率）
5
app.use(async (ctx) => {
6
  if (ctx.method === 'POST' && ctx.url === '/api/user') {
7
    // 用Buffer.allocUnsafe池化分配4字节内存
8
    const userIdBuf = Buffer.allocUnsafe(4)
9
    // 从请求体中读取4字节（假设请求体是二进制）
10
    await ctx.req.read(userIdBuf)
11
    // 解析为UInt32（大端序）
12
    const userId = userIdBuf.readUInt32BE(0)
13
    // 处理业务逻辑...
14
    ctx.body = `User ID: ${userId}`
15
    // 用完后清除内存（安全起见）
16
    userIdBuf.fill(0)
17
  }
18
})
19

20
app.listen(3000)

1
function alignPool() {
2
  // 检查偏移量末3位是否为0（8的倍数的二进制末3位是0）
3
  if (poolOffset & 0x7) {
4
    // 末3位设为1（比如13→15）
5
    poolOffset |= 0x7
6
    // 加1到下一个8的倍数（15→16）
7
    poolOffset++
8
  }
9
}

1
// 危险：用allocUnsafe存储密码
2
app.post('/api/login', (req, res) => {
3
  const passwordBuf = Buffer.allocUnsafe(16) // 未初始化的16字节
4
  passwordBuf.write(req.body.password, 0, 'utf8')
5
  // 验证密码...
6
  res.send('Login success!')
7
  // 没有清除内存！
8
})

1
const passwordBuf = Buffer.alloc(16) // 初始化所有字节为0

1
const buf = Buffer.allocUnsafe(16)
2
buf.write(req.body.password)
3
// 使用后清除
4
buf.fill(0)