Shulou(Shulou.com)06/01 Report--

This article mainly introduces the relevant knowledge of "how to achieve faster data transmission in Node.Js". The editor shows you the operation process through an actual case. The operation method is simple, fast and practical. I hope this article "how to achieve faster data transmission in Node.Js" can help you solve the problem.

In Node.js, when we return a static file to the front end, we usually read the file into the content and then write it to the underlying layer through the socket interface, thus returning it to the front end. Whether reading to memory at once or using streaming, it is inevitable to copy the data from the kernel to the user layer, and then copy the data to the kernel, which is an inefficient way because there is too much invalid replication. In nginx, efficiency can be provided through sendfile instructions. The underlying copyFile of Node.js uses the sendfile system call, but when it comes to network IO, the API is not used. Because Node.js controls the writing of data through queues. So whether it is possible to implement sendfile to provide the efficiency of the network IO. First of all, let's take a look at the benefits of sendfile.

Sendfile () copies data between one file descriptor and another. Because this copying is done within the kernel, sendfile () is more efficient than the combination of read (2) and write (2), which would require transferring data to and from user space.

We see that sendfile reduces data replication in the kernel and user layer by transferring data to the kernel, thus improving efficiency. Let's write an addon through napi to achieve this function.

# include # include static napi_value copyFile (napi_env env, napi_callback_info info) {size_t argc = 3; napi_value args [3]; / / get the input parameters of js layer. Here are three napi_get_cb_info (env, info, & argc, args, NULL, NULL); int fd1; int fd2; int len / / js is passed in a number, and v8 is converted into an object. Here, the input parameter is again converted to int napi_get_value_int32 (env, args [0], & fd1); napi_get_value_int32 (env, args [1], & fd2); napi_get_value_int32 (env, args [2], & len); int writed = sendfile (fd2, fd1, 0Len); napi_value ret; napi_create_int32 (env, writed, & ret) Return ret;} napi_value Init (napi_env env, napi_value exports) {napi_value func / / create a function and set it to the value napi_create_function (env, NULL, NAPI_AUTO_LENGTH, copyFile, NULL, & func) of the getArray property of the exports object; napi_set_named_property (env, exports, "copyFile", func); return exports } NAPI_MODULE (NODE_GYP_MODULE_NAME, Init)

Let's see how to use it. First use this addon to copy the file, similar to Node.js 's copyyFile

Const fs= require ('fs'); const {copyFile} = require ('. / build/Release/sendfile.node'); const {O_WRONLY, O_CREAT,} = fs.constants; async function test () {const [fd1, fd2] = await Promise.all ([openFile ('1.txtbread,' r'), openFile ('2.txtbread, O_WRONLY | O_CREAT)]); const {size} = await getFileInfo (fd1); console.log (fd1, fd2, size) Fs.close (fd1, () = > {}); fs.close (fd2, () = > {});} function openFile (filename, mode) {return new Promise ((resolve, reject) = > {fs.open (filename, mode, (err, fd) = > {if (err) {reject (err);} else {resolve (fd);}})) })} function getFileInfo (fd) {return new Promise ((resolve, reject) = > {fs.fstat (fd, (err, stat) = > {if (err) {reject (err)} else {resolve (stat);})} test ()

By executing the above code, we can see that the file will successfully copy the 2.txt. Then let's try the scenario of network IO.

Const fs= require ('fs'); const http = require (' http'); const {copyFile} = require ('. / build/Release/sendfile.node'); const server = http.createServer (async (req, res) = > {const fd = await openFile ('1.txtbread,' r'); const {size} = await getFileInfo (fd); const ret = copyFile (fd, res.socket._handle.fd, size); res.socket.end ();}). Const {O_WRONLY, O_CREAT,} = fs.constants; function openFile (filename, mode) {return new Promise ((resolve, reject) = > {fs.open (filename, mode, (err, fd) = > {if (err) {reject (err);} else {resolve (fd);}}) })} function getFileInfo (fd) {return new Promise ((resolve, reject) = > {fs.fstat (fd, (err, stat) = > {if (err) {reject (err)} else {resolve (stat);});})}

The above code first starts a http server, then when it receives the request, it returns the corresponding content to the front end by calling sendfile through addon, and finally closes the connection. The results are as follows.

This is the end of the introduction to "how to achieve faster data transfer in Node.Js". Thank you for reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.