首先介绍使用v8 API跟使用swig框架的不同：
（1）v8 API方式为官方提供的原生方法，功能强大而完善，缺点是需要熟悉v8 API，编写起来比较麻烦，是js强相关的，不容易支持其它脚本语言。
（2）swig为第三方支持，一个强大的组件开发工具，支持为python、lua、js等多种常见脚本语言生成C++组件包装代码，swig使用者只需要编写C++代码和swig配置文件即可开发各种脚本语言的C++组件，不需要了解各种脚本语言的组件开发框架，缺点是不支持javascript的回调，文档和demo代码不完善，使用者不多。
一、纯JS实现Node.js组件
（1）到helloworld目录下执行npm init 初始化package.json，各种选项先不管，默认即可。（2）组件的实现index.js，例如:
（3）在外层目录执行：npm install ./helloworld，helloworld于是安装到了node_modules目录中。 （4）编写组件使用代码：
二、 使用v8 API实现JS组件——同步模式
（1）编写binding.gyp， eg：（2）编写组件的实现hello.cpp，eg:
namespace cpphello {
using v8::FunctionCallbackInfo;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::String;
using v8::Value;
void Foo(const FunctionCallbackInfo
Isolate* isolate = args.GetIsolate();
args.GetReturnValue().Set(String::NewFromUtf8(isolate,"Hello World"));
}
void Init(Local
NODE_MODULE(cpphello,Init)
}
（3）编译组件
（4）编写测试js代码
（5）增加package.json 用于安装 eg：
（5）安装组件到node_modules
进入到组件目录的上级目录，执行:npm install ./helloc //注：helloc为组件目录 会在当前目录下的node_modules目录下安装hello模块，测试代码这样子写：
三、 使用v8 API实现JS组件——异步模式 上面描述的是同步组件，foo()是一个同步函数，也就是foo()函数的调用者需要等待foo()函数执行完才能往下走，当foo()函数是一个有IO耗时操作的函数时，异步的foo()函数可以减少阻塞等待，提高整体性能。
异步组件的实现只需要关注libuv的uv_queue_work API，组件实现时，除了主体代码hello.cpp和组件使用者代码，其它部分都与上面三的demo一致。
hello.cpp：
<div class="jb51code">
<pre class="brush:js;">
/*
- Node.js cpp Addons demo: async call and call back.
- gcc 4.8.2
- author:cswuyg
- Date:2016.02.22
- */
include
include <node.h>
include <uv.h>
include
include <unistd.h>
include <pthread.h>
namespace cpphello {
using v8::FunctionCallbackInfo;
using v8::Function;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
using v8::Exception;
using v8::Persistent;
using v8::HandleScope;
using v8::Integer;
using v8::String;
// async task
struct MyTask{
uv_work_t work;
int a{0};
int b{0};
int output{0};
unsigned long long work_tid{0};
unsigned long long main_tid{0};
Persistent
};
// async function
void query_async(uv_work_t work) {
MyTask task = (MyTask)work->data;
task->output = task->a + task->b;
task->work_tid = pthread_self();
usleep(1000 1000 * 1); // 1 second
}
// async complete callback
void query_finish(uv_work_t work,int status) {
Isolate isolate = Isolate::GetCurrent();
HandleScope handle_scope(isolate);
MyTask task = (MyTask)work->data;
const unsigned int argc = 3;
std::stringstream stream;
stream << task->main_tid;
std::string main_tid_s{stream.str()};
stream.str("");
stream << task->work_tid;
std::string work_tid_s{stream.str()};
Local<Value> argv[argc] = {
Integer::New(isolate,task->output),String::NewFromUtf8(isolate,main_tid_s.c_str()),work_tid_s.c_str())
};
Local<Function>::New(isolate,task->callback)->Call(isolate->GetCurrentContext()->Global(),argc,argv);
task->callback.Reset();
delete task;}
// async main
void async_foo(const FunctionCallbackInfo
Isolate isolate = args.GetIsolate();
HandleScope handle_scope(isolate);
if (args.Length() != 3) {
isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate,"arguments num : 3")));
return;
}
if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsFunction()) {
isolate->ThrowException(Exception::TypeError(String::NewFromUtf8(isolate,"arguments error")));
return;
}
MyTask my_task = new MyTask;
my_task->a = args[0]->ToInteger()->Value();
my_task->b = args[1]->ToInteger()->Value();
my_task->callback.Reset(isolate,Local
my_task->work.data = my_task;
my_task->main_tid = pthread_self();
uv_loop_t *loop = uv_default_loop();
uv_queue_work(loop,&my_task->work,query_async,query_finish);
}
void Init(Local
NODE_MODULE(cpphello,Init)
}
