一、node-gyp

1、node-gyp 是一种构建工具，用于将 c++ 打包成 .node 后缀的 NodeJS 模块，经过 node-gyp 的构建就可以在 NodeJS 环境下使用 c++ 写的模块
2、node-gyp 依赖 python2.7(不能用3.xx版本)、make(UNIX系统下构建工具程序)/msbuild(window下构建工具)、gcc(C++编译工具包)

// mac
brew install python2.7
brew install -y build-essential
// win
npm i -g --production windows-build-tools
// 安装 node-gyp
npm i -g node-gyp

3、node-gyp 常用命令
a、configure
为当前模块生成构建配置文件，win下是 .msvc，unix 下是 .makefile
b、build
构建模块，wind下是调用 msbuild，unix 下是 make
c、rebuild
一次性执行 configure 和 build
d、install
为指定版本的 Node.js 安装开发环境依赖文件，我们电脑里用户目录下的 .node-gyp 就是 install 的结果
e、remove/ clean
移除指定版本的 Node.js 安装开发环境依赖文件 / 移除生成的构建文件。

所以一般是先 node-gyp install 安装开发环境依赖（一些头文件）；然后编写 .cpp；然后 node-gyp rebuild

3、binding.gyp 是 node-gyp 的配置文件，就像 webpack.config.js 是 webpack 的配置文件一样。其本身是一个json文件，定义了各种编译相关的内容：

{
    "targets": [{
        "target_name": "map", // 编译后文件名为 map.node
        "sources": [
            "map.cc" // 编译入口文件为 map.cc
        ]
    }]
}

4、一个简单的 demo

// binding.gyp
{
    "targets": [{
        "target_name": "first",
        "sources": [
            "first.cpp"
        ]
    }]
}
// first.cpp
#include <node.h>
namespace __first__
{
  using v8::FunctionCallbackInfo;
  using v8::Isolate;
  using v8::Local;
  using v8::Object;
  using v8::String;
  using v8::Value;
  void Method(const FunctionCallbackInfo<Value> &args)
  {
    Isolate *isolate = args.GetIsolate();
    args.GetReturnValue().Set(String::NewFromUtf8(isolate, "first build"));
  }
  void init(Local<Object> exports)
  {
    NODE_SET_METHOD(exports, "first", Method);
  }
  NODE_MODULE(addon, init)
} // namespace __first__

执行 node-gyp rebuild 后就会生成 build 文件夹，里面包含了构建配置文件和最终构建产物 first.node：

5、binding.gyp 常用配置语法
配置文件十分灵活，甚至可以调用子进程进行运算
a、变量
分为预定义变量（全大写、下划线，如OS）、用户变量（在 variables 字段中声明）、自动变量
b、指令
指令以<! 或者 <!@ 开头，如：

'variables':[
    'foo':'<! (echo BUild Date <!(date))',
]

c、条件分支 conditions/target_conditions
d、数组过滤器（排除！、匹配/）
6、binding.gyp 常用配置字段
a、预编译 defines ，用于添加预编译宏

{
    "targets": [{
        "target_name": "first",
        "defines":[
            "BAR=some_value"
        ]
    }]
}

b、头文件搜索路径 include_dirs

{
    "targets": [{
        "target_name": "first",
        "include_dirs":[
            '..',
          'include'
        ]
    }]
}

c、依赖库 libraries

"conditions":[
    ["OS==\"mac\"",{}],
  ["OS==\"linux\"",{
      "libraries":["../lib/xxx.a"]
  }]
]

d、编译类型 type

"type": "shared_library"  # 一般动态链接库
"type": "static_library"  # 静态链接库
"type": "loadable_module"  # C++扩展动态链接库，默认值

e、依赖 dependencies
如果你的C++扩展使用了第三方C++代码，就需要在binding.gyp中将其编译为静态链接库，使其可以被主 target 所依赖

"targets":[
  {
      "target_name":"a",
    "type":"static_library",
    "sources":["./deps/xxx/x.c"]
  },
  {
      "target_name":"a",
    "dependencies":["a"],
    "sources":["./src/xx.cc"]
  }
]

f、复制 copies

"copies":[
  {
      "destination":"<!(module_root_dir)/build/Release/",
    "files":["<!(module_root_dir)/src/third_party/lib/windows/xxx.dll"]
  }
]

g、常用变量
module_root_dir 模块根目录
node_root_dir Node.js 一些文件的根目录
node_gyp_dir node-gyp 这个包的根目录
node_lib_file 用于编译时的 Node.js 库文件

二、编写简单 Addon

• 固定套路

1、模块注册入口 NODE_MODULE(addon, init)
2、init 函数内挂载需要导出的内容 NODE_SET_METHOD(exports, “first”, Method);
3、实现 Method，通过 args.GetReturnValue().Set 设置返回值，注意 Set 参数必须是一个句柄，而不是一个值

#include <node.h> // 引入头文件，包含了一些类型定义、宏定义以及其它头文件
namespace __first__
{
  using v8::FunctionCallbackInfo;
  using v8::Isolate;
  using v8::Local;
  using v8::Object;
  using v8::String;
  using v8::Value;
  void Method(const FunctionCallbackInfo<Value> &args) // 方法体
  {
    Isolate *isolate = args.GetIsolate();
    args.GetReturnValue().Set(String::NewFromUtf8(isolate, "first build"));
  }
  void init(Local<Object> exports)
  {
    NODE_SET_METHOD(exports, "first", Method); // 在 exports 对象上挂载 first 方法，方法体为 Method
  }
  NODE_MODULE(addon, init) // Native 模块注册入口
} // namespace __first__

• 可以接受参数的函数 ```cpp

  include

namespace demo {

using v8::Exception; using v8::FunctionCallbackInfo; using v8::Isolate; using v8::Local; using v8::Number; using v8::Object; using v8::String; using v8::Value;

// 实现 “add” 函数 void Add(const FunctionCallbackInfo &args) { Isolate *isolate = args.GetIsolate();

// 判断参数个数是否合法
if (args.Length() < 2)
{
  // 不合法则跑错
  isolate->ThrowException(Exception::TypeError(
      String::NewFromUtf8(isolate, "Wrong number of arguments")));
  return;
}
// 判断参数类型是否合法
if (!args[0]->IsNumber() || !args[1]->IsNumber())
{
  isolate->ThrowException(Exception::TypeError(
      String::NewFromUtf8(isolate, "Wrong arguments")));
  return;
}
// 计算第一个参数加第二个参数的 `double` 值
// 并新生成一个 Local<Number> 句柄，将计算出来的 `double` 传入
double value = args[0]->NumberValue() + args[1]->NumberValue();
Local<Number> num = Number::New(isolate, value);
// 设置返回值为新生成的 `num`
args.GetReturnValue().Set(num);

}

void Init(Local