架构师AI杜

Appearance

Node.js Buffer 面试题 ​

1. 什么是 Buffer？ ​

问题：什么是 Buffer？它在 Node.js 中有什么作用？

答案： Buffer 是 Node.js 中用于处理二进制数据的类。由于 JavaScript 最初设计用于处理字符串，缺乏对二进制数据的有效支持，Buffer 填补了这一空白。

主要作用：

  • 处理二进制数据（如文件、网络数据）
  • 与流（Stream）API 配合使用
  • 处理非 UTF-8 编码的数据
  • 提高 I/O 操作性能

特点：

  • 类似于整数数组，但大小固定
  • 存储在 V8 堆内存之外的原始内存中
  • 一旦创建，大小不可改变
  • 全局可用，无需 require

2. 创建 Buffer 的方法 ​

问题：如何创建 Buffer？有哪些方法？

答案：

创建方法：

javascript
// 1. Buffer.alloc() - 创建指定大小的 Buffer（安全，初始化为0）
const buf1 = Buffer.alloc(10);  // 创建 10 字节的 Buffer
console.log(buf1);  // <Buffer 00 00 00 00 00 00 00 00 00 00>

// 2. Buffer.allocUnsafe() - 创建指定大小的 Buffer（不安全，未初始化）
const buf2 = Buffer.allocUnsafe(10);  // 可能包含旧数据
console.log(buf2);  // <Buffer ...随机数据...>

// 3. Buffer.from() - 从字符串、数组或 Buffer 创建
const buf3 = Buffer.from('Hello');  // 从字符串创建
const buf4 = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]);  // 从数组创建
const buf5 = Buffer.from(buf3);  // 从 Buffer 创建（复制）

// 4. Buffer.from() 带编码
const buf6 = Buffer.from('你好', 'utf8');  // 默认编码
const buf7 = Buffer.from('你好', 'utf16le');
const buf8 = Buffer.from('68656c6c6f', 'hex');  // 从十六进制字符串
const buf9 = Buffer.from('SGVsbG8=', 'base64');  // 从 Base64 字符串

方法对比：

方法初始化性能使用场景
Buffer.alloc()零填充较慢安全敏感场景
Buffer.allocUnsafe()未初始化快性能敏感，需立即填充
Buffer.from()根据数据源中等从现有数据创建

3. Buffer 的编码 ​

问题：Buffer 支持哪些编码？如何使用？

答案：

支持的编码：

  • utf8 - 多字节编码的 Unicode 字符（默认）
  • utf16le - 小端序 UTF-16 编码
  • latin1 - ISO-8859-1 编码
  • ascii - 7 位 ASCII 编码
  • base64 - Base64 编码
  • hex - 十六进制编码
  • binary - 二进制编码（已废弃）

使用示例：

javascript
const buf = Buffer.from('Hello World');

// 转换为不同编码的字符串
console.log(buf.toString('utf8'));      // Hello World
console.log(buf.toString('hex'));       // 48656c6c6f20576f726c64
console.log(buf.toString('base64'));    // SGVsbG8gV29ybGQ=

// 从十六进制创建 Buffer
const hexBuf = Buffer.from('48656c6c6f', 'hex');
console.log(hexBuf.toString());  // Hello

// 从 Base64 创建 Buffer
const base64Buf = Buffer.from('SGVsbG8=', 'base64');
console.log(base64Buf.toString());  // Hello

// 处理中文字符
const chinese = Buffer.from('你好世界', 'utf8');
console.log(chinese.length);  // 12（UTF-8 中文字符占 3 字节）
console.log(chinese.toString('utf8'));  // 你好世界

4. Buffer 的操作方法 ​

问题：Buffer 有哪些常用的操作方法？

答案：

读写操作：

javascript
const buf = Buffer.alloc(256);

// 写入数据
buf.write('Hello', 0);  // 从偏移量 0 开始写入
buf.write(' World', 5); // 从偏移量 5 开始写入

// 读取单个字节
console.log(buf[0]);    // 72 (H 的 ASCII 码)
console.log(buf[1]);    // 101 (e 的 ASCII 码)

// 修改单个字节
buf[0] = 74;  // 改为 'J'
console.log(buf.toString());  // Jello World

// 读取指定长度
console.log(buf.toString('utf8', 0, 5));  // Hello

切片和复制：

javascript
const buf = Buffer.from('Hello World');

// slice() - 创建视图（共享内存）
const sliced = buf.slice(0, 5);
console.log(sliced.toString());  // Hello
sliced[0] = 74;  // 修改会影响原 Buffer
console.log(buf.toString());  // Jello World

// subarray() - 与 slice() 类似（ES2015+）
const sub = buf.subarray(6, 11);
console.log(sub.toString());  // World

// copy() - 复制到另一个 Buffer
const target = Buffer.alloc(5);
buf.copy(target, 0, 0, 5);
console.log(target.toString());  // Hello

比较和查找：

javascript
const buf1 = Buffer.from('ABC');
const buf2 = Buffer.from('BCD');
const buf3 = Buffer.from('ABC');

// 比较
console.log(buf1.equals(buf3));  // true
console.log(buf1.compare(buf2)); // -1 (buf1 < buf2)

// 查找
const buf = Buffer.from('Hello World Hello');
console.log(buf.indexOf('World'));     // 6
console.log(buf.indexOf('Hello', 7));  // 12（从索引 7 开始查找）
console.log(buf.includes('World'));    // true

// 填充
const buf4 = Buffer.alloc(10);
buf4.fill('A');
console.log(buf4.toString());  // AAAAAAAAAA

buf4.fill('B', 2, 5);
console.log(buf4.toString());  // AABBBAAAAA

拼接 Buffer：

javascript
const buf1 = Buffer.from('Hello ');
const buf2 = Buffer.from('World');

// concat() - 拼接多个 Buffer
const combined = Buffer.concat([buf1, buf2]);
console.log(combined.toString());  // Hello World

// 指定总长度（性能优化）
const bufs = [Buffer.from('A'), Buffer.from('B'), Buffer.from('C')];
const result = Buffer.concat(bufs, 3);  // 预先知道总长度

5. Buffer 与字符串的区别 ​

问题：Buffer 和字符串有什么区别？如何选择使用？

答案：

主要区别：

特性StringBuffer
存储内容Unicode 字符原始二进制数据
编码UTF-16多种编码可选
可变性不可变可变（内容可变，大小不可变）
内存位置V8 堆V8 堆外内存
适用场景文本处理二进制数据、I/O 操作

选择建议：

javascript
// 使用 String
const text = 'Hello World';  // 纯文本操作
const json = JSON.stringify(data);  // JSON 处理

// 使用 Buffer
const fileData = fs.readFileSync('image.png');  // 读取二进制文件
const networkData = socket.read();  // 网络数据
const encrypted = crypto.createCipher('aes', key).update(data);  // 加密操作

转换：

javascript
// String -> Buffer
const buf = Buffer.from('Hello', 'utf8');

// Buffer -> String
const str = buf.toString('utf8');

// 注意：编码不匹配会导致乱码
const buf2 = Buffer.from('你好', 'utf8');
console.log(buf2.toString('latin1'));  // åä½ å¥½ (乱码)

6. Buffer 的性能优化 ​

问题：如何优化 Buffer 的使用性能？

答案：

优化策略：

  1. 使用 Buffer.allocUnsafe() 并立即填充：
javascript
// 快但不安全（如果未填充就使用）
const buf = Buffer.allocUnsafe(1024);
// 立即填充
buf.fill(0);
// 或使用 write 方法
buf.write('data', 0);
  1. 重用 Buffer（对象池模式）：
javascript
class BufferPool {
  constructor(size, count) {
    this.buffers = [];
    this.size = size;
    for (let i = 0; i < count; i++) {
      this.buffers.push(Buffer.allocUnsafe(size));
    }
  }
  
  acquire() {
    return this.buffers.pop() || Buffer.allocUnsafe(this.size);
  }
  
  release(buf) {
    if (buf.length === this.size) {
      this.buffers.push(buf);
    }
  }
}

const pool = new BufferPool(1024, 10);
const buf = pool.acquire();
// 使用 buffer...
pool.release(buf);
  1. 避免频繁的小 Buffer 创建：
javascript
// 不好：频繁创建小 Buffer
for (let i = 0; i < 1000; i++) {
  const buf = Buffer.from('small data');
  process(buf);
}

// 好：预分配大 Buffer，分段使用
const bigBuf = Buffer.allocUnsafe(10000);
let offset = 0;
for (let i = 0; i < 1000; i++) {
  const data = 'small data';
  bigBuf.write(data, offset);
  offset += data.length;
}
  1. 使用 Buffer.copy() 代替 concat()（大量操作时）：
javascript
// concat 会创建新 Buffer
const result = Buffer.concat([buf1, buf2, buf3]);

// copy 可以重用已有 Buffer
const target = Buffer.allocUnsafe(buf1.length + buf2.length + buf3.length);
let offset = 0;
offset += buf1.copy(target, offset);
offset += buf2.copy(target, offset);
buf3.copy(target, offset);
  1. 使用 TypedArray 视图（需要时）：
javascript
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);

// 创建 Uint32Array 视图（不复制数据）
const uint32View = new Uint32Array(
  buf.buffer, 
  buf.byteOffset, 
  buf.length / 4
);

console.log(uint32View);  // Uint32Array [67305985, 134678021]

7. Buffer 的内存管理 ​

问题：Buffer 的内存是如何管理的？

答案：

内存分配：

  • Buffer 内存由 Node.js 的 C++ 层分配
  • 小于 4KB 的 Buffer 使用内存池（slab allocation）
  • 大于 4KB 的 Buffer 直接分配

内存池机制：

javascript
// 小 Buffer（< 4KB）使用内存池
const smallBuf = Buffer.alloc(1024);  // 从内存池分配

// 大 Buffer（>= 4KB）直接分配
const largeBuf = Buffer.alloc(8192);  // 直接分配

内存限制：

javascript
// 查看内存使用
console.log(process.memoryUsage());
// {
//   rss: 23456789,        // 常驻集大小
//   heapTotal: 12345678,  // V8 堆总大小
//   heapUsed: 9876543,    // V8 堆已使用
//   external: 1234567,    // 外部内存（包括 Buffer）
//   arrayBuffers: 123456  // ArrayBuffer/Buffer 使用的内存
// }

// 设置最大旧生代内存大小
// node --max-old-space-size=4096 app.js

垃圾回收：

  • Buffer 内存由 V8 的垃圾回收器管理
  • 当 Buffer 不再被引用时，内存会被回收
  • 可以使用 buf = null 帮助垃圾回收

8. Buffer 的安全问题 ​

问题：使用 Buffer 时需要注意哪些安全问题？

答案：

安全问题：

  1. Buffer.allocUnsafe() 的数据泄漏：
javascript
// 危险：可能包含敏感数据
const buf = Buffer.allocUnsafe(1024);
console.log(buf.toString());  // 可能输出之前程序的敏感数据

// 安全：使用 alloc() 或立即填充
const safeBuf = Buffer.alloc(1024);  // 自动零填充
// 或
const unsafeBuf = Buffer.allocUnsafe(1024);
unsafeBuf.fill(0);  // 手动填充
  1. 整数溢出：
javascript
// Buffer 长度是 32 位无符号整数
const huge = Buffer.alloc(0xFFFFFFFF + 1);  // 错误：超出最大长度

// 检查长度
const size = calculateSize();
if (size > Buffer.MAX_LENGTH) {
  throw new Error('Buffer size too large');
}
  1. 编码攻击：
javascript
// 恶意输入可能导致问题
const userInput = '...恶意数据...';
const buf = Buffer.from(userInput, 'utf8');

// 验证输入长度
if (userInput.length > MAX_INPUT_SIZE) {
  throw new Error('Input too large');
}
  1. 原型污染：
javascript
// 避免修改 Buffer 原型
// 不好
Buffer.prototype.customMethod = function() { ... };

// 好：使用工具函数
function customBufferMethod(buf) { ... }

最佳实践：

javascript
// 1. 优先使用 Buffer.alloc()
const buf = Buffer.alloc(size);

// 2. 验证输入数据
function safeBufferFrom(data, encoding) {
  if (typeof data !== 'string' && !Array.isArray(data) && !Buffer.isBuffer(data)) {
    throw new TypeError('Invalid data type');
  }
  return Buffer.from(data, encoding);
}

// 3. 限制 Buffer 大小
const MAX_BUFFER_SIZE = 100 * 1024 * 1024;  // 100MB
function createSafeBuffer(size) {
  if (size > MAX_BUFFER_SIZE) {
    throw new Error('Buffer size exceeds limit');
  }
  return Buffer.alloc(size);
}

9. Buffer 在流中的应用 ​

问题：Buffer 在 Node.js 流中是如何使用的？

答案：

流中的 Buffer：

javascript
const fs = require('fs');

// 可读流 - 数据以 Buffer 形式提供
const readable = fs.createReadStream('file.txt');
readable.on('data', (chunk) => {
  console.log(Buffer.isBuffer(chunk));  // true
  console.log(`收到 ${chunk.length} 字节`);
});

// 可写流 - 接收 Buffer 或字符串
const writable = fs.createWriteStream('output.txt');
writable.write(Buffer.from('Hello'));
writable.write(' World');  // 字符串会自动转换为 Buffer
writable.end();

对象模式 vs Buffer 模式：

javascript
const { Transform } = require('stream');

// Buffer 模式（默认）
const bufferTransform = new Transform({
  transform(chunk, encoding, callback) {
    // chunk 是 Buffer
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// 对象模式
const objectTransform = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    // chunk 是 JavaScript 对象
    this.push({ ...chunk, processed: true });
    callback();
  }
});

背压处理：

javascript
const fs = require('fs');

const readable = fs.createReadStream('large-file.txt');
const writable = fs.createWriteStream('output.txt');

readable.on('data', (chunk) => {
  // 检查可写流是否已满
  if (!writable.write(chunk)) {
    // 暂停读取，直到可写流准备好
    readable.pause();
    writable.once('drain', () => {
      readable.resume();
    });
  }
});

10. Buffer 的常见问题 ​

问题：Buffer 使用中常见的问题有哪些？如何解决？

答案：

常见问题及解决方案：

  1. 乱码问题：
javascript
// 问题：中文字符被截断
const buf = Buffer.from('你好世界', 'utf8');
const partial = buf.slice(0, 5);  // 截断了一个 UTF-8 字符
console.log(partial.toString());  // 乱码

// 解决方案：使用 string_decoder
const { StringDecoder } = require('string_decoder');
const decoder = new StringDecoder('utf8');

const buf1 = Buffer.from([0xe4, 0xbd, 0xa0]);  // '你'
const buf2 = Buffer.from([0xe5, 0xa5, 0xbd]);  // '好'

console.log(decoder.write(buf1));  // 你
console.log(decoder.write(buf2));  // 好
  1. 大文件处理：
javascript
// 问题：一次性读取大文件导致内存溢出
const data = fs.readFileSync('huge-file.zip');  // 内存不足

// 解决方案：使用流
const stream = fs.createReadStream('huge-file.zip');
stream.on('data', (chunk) => {
  // 分块处理
  processChunk(chunk);
});
  1. Buffer 比较：
javascript
// 问题：直接使用 === 比较 Buffer
const buf1 = Buffer.from('hello');
const buf2 = Buffer.from('hello');
console.log(buf1 === buf2);  // false（不同对象）

// 解决方案：使用 equals() 或 compare()
console.log(buf1.equals(buf2));  // true
console.log(buf1.compare(buf2) === 0);  // true
  1. 类型检查：
javascript
// 问题：如何检查是否为 Buffer
function processData(data) {
  if (Buffer.isBuffer(data)) {
    // 处理 Buffer
  } else if (typeof data === 'string') {
    // 处理字符串
  }
}
  1. JSON 序列化：
javascript
// 问题：Buffer 不能直接 JSON 序列化
const data = { content: Buffer.from('hello') };
console.log(JSON.stringify(data));  // {"content":{"type":"Buffer","data":[104,101,108,108,111]}}

// 解决方案：转换为 Base64
const safeData = {
  content: data.content.toString('base64'),
  encoding: 'base64'
};
console.log(JSON.stringify(safeData));

// 还原
const restored = Buffer.from(safeData.content, safeData.encoding);