Detailed explanation of the use of Node.js Buffer

JavaScript was originally designed for browsers and has no mechanism for reading or manipulating binary data streams. The introduction of the Buffer class gives NodeJS the ability to operate file streams or network binary streams. [Video tutorial recommendation: node js tutorial]

Basic concept of Buffer

The memory allocation of the Buffer object is not in the heap memory of V8, but is done by Node at the C level Memory application can be understood as a separate space in the memory, but the allocation of memory during use is completed by the Node level, and the release is also automatically controlled by the gc mechanism of v8 in Node. The basic operations of Buffer will not be described in detail here. The official documentation is very detailed.

Buffer performance comparison

Usually, during network transmission, data needs to be converted into Buffer. Let's do a performance comparison experiment.

1. Use a pure string to return to the client

const http = require('http');

let hello = ''
for (var i = 0; i < 10240; i++) {
  hello += "a";
}

console.log(`Hello：${hello.length}`)
// hello = Buffer.from(hello);

http.createServer((req, res) => {
  res.writeHead(200);
  res.end(hello);
}).listen(8001);

Use ab -c 200 -t 100 http ://127.0.0.1:8001/ command to perform performance testing, initiate 200 concurrent clients

Using strings, QPS can reach 4019.70, and the transmission rate is 40491.45KB per second.

2. Use Buffer. Convert the string into a Buffer object and send it to the client.

const http = require('http');

let hello = ''
for (var i = 0; i < 10240; i++) {
  hello += "a";
}

console.log(`Hello：${hello.length}`)
hello = Buffer.from(hello);

http.createServer((req, res) => {
  res.writeHead(200);
  res.end(hello);
}).listen(8001);

Uncomment the Buffer conversion, also use ab -c 200 -t 100 http://127.0.0.1:8001/ test, also initiate 200 Concurrent clients

Use Buffer, QPS reaches 7130.05, and the transfer rate is 71822.74KB per second.
The performance is 177% of the original, which greatly saves server resources.
The above comparison example is referred to "Introduction to Node JS in a Simple Way".

So the question is, why is there such a big performance improvement?

The reason is actually very simple. In NodeJS, when performing http transmission, if the returned type is string, the string type parameters will be converted into Buffer , returned to the client bit by bit through the Stream stream in NodeJS. If we directly return the Buffer type, there will be no conversion operation and direct return, which reduces the reuse rate of the CPU. This part of the logic can be found in the Node source codehttps://github.com/nodejs/node/blob/v10.9.0/lib/_http_outgoing.js#L612

In the above performance comparison example, When returning string, each request needs to replace string with a Buffer and return it; when returning the Buffer directly, this Buffer is stored in the memory when we start the service. Each request can directly return the Buffer in the memory, so the QPS before and after using the Buffer is improved a lot.

Therefore, when we write business code, some resources can be converted into Buffer types (such as js, css and other static resource files) in advance, and the buffer can be directly returned to the client. For example, in some file forwarding scenarios, The obtained content is stored in a Buffer and forwarded directly to avoid additional conversion operations.

Reference:

• http://nodejs.cn/api/buffer.html

• https ://book.douban.com/subje...

This article is reproduced from: https://segmentfault.com/a/1190000016056466

For more programming-related knowledge, please visit: Programming Teaching! !

The above is the detailed content of Detailed explanation of the use of Node.js Buffer. For more information, please follow other related articles on the PHP Chinese website!