How to use a .node file?

.node files are compiled extensions, typically written in C or C++, that can be directly loaded using Node.js's require() function. These files enable Node.js to perform low-level system operations, enhancing performance or implementing functionalities not supported by Node.js itself.

Usage Steps

1. Install necessary compilation tools

To compile or build .node files, you need to install the C/C++ compilation environment. On Windows, this usually involves installing Visual Studio and related C++ tools; on Linux and Mac, you typically need to install GCC or Clang.

2. Use node-gyp

node-gyp is a native plugin build tool for Node.js. You need to install it in your project to help compile and build .node files.

bash
npm install -g node-gyp

3. Write binding file

Create a binding.gyp file to define how to build this Node.js plugin. This file is a JSON-style configuration file.

Example:

json
{
  "targets": [
    {
      "target_name": "addon",
      "sources": [ "src/addon.cc" ]
    }
  ]
}

4. Write C/C++ code

In your project, write C or C++ code as needed. For example, create an addon.cc file containing the extension code.

5. Build the project

In the project root directory, run the following commands to build the project:

bash
node-gyp configure
node-gyp build

6. Use .node files in Node.js

Once compiled, you can load the .node file in Node.js code using require().

javascript
const addon = require('./build/Release/addon');
console.log(addon.hello());

In this example, addon.hello() calls the hello method defined in the C++ code.

Practical Application Example

Suppose we need a performance-critical feature, such as image processing or mathematical calculations. Using JavaScript in Node.js might be too slow for such tasks. In this case, we can write the relevant part in C++ and compile it into a .node file, which Node.js can call to enhance performance.

Summary

In summary, using .node files is mainly to integrate high-performance native code implementations into Node.js projects. Although it involves more programming and build steps, it is highly valuable for applications with extremely high performance requirements.