What is buffer? Learn more about the buffer module in Nodejs

What is buffer? The following article will give you an in-depth understanding of the buffer module in Nodejs, and introduce the methods of creating, copying, splicing, intercepting, filling Buffers, and converting Buffers and Strings. I hope it will be helpful to everyone!

1.What is buffer?

We know that JS has corresponding method APIs for operating strings, arrays, numbers, Boolean values, etc., while in Node, file operations, network communications, database operations, and data transmission are also required. and other capabilities; files are represented in binary form at the storage level, and data transmission in http requests and responses is also transmitted in binary data, so the current JS capabilities alone are not enough, which is why Node## The buffer module is provided in #.

That is: giving NodeJS the ability to manipulate binary data like strings. Buffer is also called

temporary storage area, which is a section of memory that temporarily stores input and output binary data.

In a previous article

Talk about the core module in Nodejs: stream module (see how to use), we learned that when reading large files, Generally, it is not read into the memory all at once, but a data block is read in the form of a stream, and the continuous data blocks form the concept of data stream. During the process of reading and writing data blocks, the data will first be stored in the memory of buffer (temporary buffer area) to be processed.

1.1 Understand buffer memory allocation

#The memory allocation of the buffer object is not in the heap memory of V8, but at the C level of Node Implement memory application; in order to efficiently use the application to obtain memory, Node adopts the slab allocation mechanism (a dynamic memory management mechanism).

1. 2 The global nature of the buffer

Node has already installed the buffer into the memory when the process starts and puts it into the global The object can be introduced without require when using it, but it is still officially recommended to reference it explicitly through the import or require statement.

2. Create Buffer

In addition to reading files and obtaining http requests, buffer instances can also be constructed and created manually.

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

Parameters:

size: buffer length
• fill: pre-filled value, default value: 0
• encoding: if fill is a string, it is the encoding of the string, default: utf-8

• import { Buffer } from 'buffer';
  
  const buf = Buffer.alloc(8);
  
  console.log(buf);
  // <Buffer 00 00 00 00 00 00 00 00>

2.2 Buffer.allocUnsafe(size)

Parameters:

size: The required length of the new buffer
• The underlying memory of Buffer instances created in this way will not be initialized. The contents of the newly created Buffer are unknown and may contain sensitive data.

• import { Buffer } from 'buffer';
  
  const buf = Buffer.allocUnsafe(8);
  
  console.log(buf);
  // <Buffer e8 bf 99 e6 98 af e4 b8 80 e6>

2.3 Buffer.from(string[, encoding])

Create a new buffer containing the incoming string

Parameters:

string: string
• encoding: encoding, default value: utf-8

• import { Buffer } from 'buffer';
  
  const buf = Buffer.from('hello buffer');
  
  console.log(buf);
  // <Buffer 68 65 6c 6c 6f 20 62 75 66 66 65 72>

2.4 Buffer.from(array)

Use bytes in the range

0 – 255 array to allocate new Buffer.

import { Buffer } from 'buffer';

const array = [0x62, 0x78, 0x84];
const buf = Buffer.from(array);

console.log(buf);
// <Buffer 62 78 84>

3. Copy Buffer

3.1 Buffer.from(buffer)

Parameters:

buffer, the buffer instance to be copied

• import { Buffer } from 'buffer';
  // 新建
  const buf1 = Buffer.alloc(10, 2);
  // 复制
  const buf2 = Buffer.from(buf1);
  
  console.log(buf1);
  // <Buffer 02 02 02 02 02 02 02 02 02 02>
  console.log(buf2);
  // <Buffer 02 02 02 02 02 02 02 02 02 02>

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

Copy the buf instance to the target target

import { Buffer } from 'buffer';

const buf1 = Buffer.alloc(10, 2);
const buf2 = Buffer.allocUnsafe(10)
// 将buf1复制到buf2
buf1.copy(buf2);

console.log(buf1);
// <Buffer 02 02 02 02 02 02 02 02 02 02>
console.log(buf2);
// <Buffer 02 02 02 02 02 02 02 02 02 02>

4. Splice Buffer

4.1 Buffer.concat(list[, totalLength])

Returns a new buffer in which all buffer instances in the list are connected together

Parameters:

list: |
• totalLength: The total length of the connection.

Note:

If the list has no entries, or totalLength is 0, a new zero-length Buffer is returned.
• If totalLength is not provided, it is calculated from the Buffer instances in the list by adding their lengths.

• import { Buffer } from 'buffer';
  
  const buf1 = Buffer.alloc(4, 2);
  const buf2 = Buffer.alloc(4, 3);
  
  const buf3 = Buffer.concat([buf1, buf2]);
  
  console.log(buf1); // <Buffer 02 02 02 02>
  console.log(buf2); // <Buffer 03 03 03 03>
  console.log(buf3); // <Buffer 02 02 02 02 03 03 03 03>

5. Intercept Buffer

##5.1 buf.slice([start[, end]])Return a new Buffer instance from the buf instance. The returned new Buffer instance is only a reference to the source buf instance, that is, modifications to the newly returned instance will affect the original Buffer instance

Parameters ：

• start: 起始位置，默认0
• end: 结束位置，默认buf.length

import { Buffer } from 'buffer';

const buf1 = Buffer.alloc(10, 2);
// 截取
const buf2 = buf1.slice(1,4);
// 截取部分修改
buf2[0] = 0x63;

console.log(buf1);
// <Buffer 02 63 02 02 02 02 02 02 02 02>
console.log(buf2);
// <Buffer 63 02 02>

6. 填充Buffer

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

参数：

• value,填充值
• offset: 在开始填充 buf 之前要跳过的字节数,默认值0
• end: 结束填充buf(不包括在内)的位置，默认值buf.length
• encoding,如果value值为字符串，则为字符串编码，默认utf-8

import { Buffer } from 'buffer';

const buf1 = Buffer.allocUnsafe(8).fill(2);

console.log(buf1);
// <Buffer 02 02 02 02 02 02 02 02>

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

根据 encoding 中的字符编码将 string 写入 buf 的 offset 处。

注意：length 参数是要写入的字节数。 如果 buf 没有足够的空间来容纳整个字符串，则只会写入 string 的一部分

参数：

• string: 写入的字符串值
• offset: 开始写入 string 之前要跳过的字节数,默认值为0
• length: 写入的最大字节数，默认值buf.length - offset
• encoding: 编码，默认utf-8

import { Buffer } from 'buffer';
// buf1 length为12
const buf1 = Buffer.alloc(12, 3);
// write offset大于buf1.length,写入无效
buf1.write('hello', 12);

console.log(buf1);
// <Buffer 03 03 03 03 03 03 03 03 03 03 03 03>
// 部分写入
buf1.write(&#39;hello&#39;, 10);
// <Buffer 03 03 03 03 03 03 03 03 03 03 68 65>

7. Buffer工具方法

7.1 Buffer.isBuffer(obj)

检验传入obj是否为buffer

import { Buffer } from 'buffer';

const buf1 = Buffer.alloc(12, 3);

console.log(Buffer.isBuffer(buf1));
// true

7.2 Buffer.isEncoding(encoding)

检查传入的编码名称是否被Buffer所支持

import { Buffer } from 'buffer';

console.log(Buffer.isEncoding('utf-8'))
// true

8. Buffer与String的转换

Buffer转String

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

参数：

• encoding:使用的字符串编码，默认utf-8
• start,开始位置，默认0
• end,结束位置，默认buf.length

import { Buffer } from 'buffer';

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 是 &#39;a&#39; 的十进制 ASCII 值。
  buf1[i] = i + 97;
}

console.log(buf1.toString())
// abcdefghijklmnopqrstuvwxyz

String转Buffer

8.2 Buffer.from(string[, encoding])

参数：

• string: 字符串
• encoding: 编码,默认值：utf-8

import { Buffer } from 'buffer';

const buf = Buffer.from('hello buffer');

console.log(buf);
// <Buffer 68 65 6c 6c 6f 20 62 75 66 66 65 72>

9. Buffer与Array的对比

9.1 与Array类似点

• 可以使用下标获取指定位置的值
• 可以使用length属性获取Buffer大小
• 可以使用for...of遍历

9.2 与Array不同之处

• 存储的是16进制的两位数
• 值为0-255
• 支持多种编码格式
• 内存不在v8堆中分配
• 底层有c++实现，上层由js控制

更多node相关知识，请访问：nodejs 教程！！

The above is the detailed content of What is buffer? Learn more about the buffer module in Nodejs. For more information, please follow other related articles on the PHP Chinese website!