除了包装和返回 C++ 对象，也可以通过使用 Node.js 的辅助函数 node::ObjectWrap::Unwrap 进行去包装来传递包装的对象。 以下例子展示了一个 add() 函数，它可以把两个 MyObject 对象作为输入参数：

    1. // addon.cc
    2. #include <node.h>
    3. #include <node_object_wrap.h>
    4. #include "myobject.h"
    6. namespace demo {
    8. using v8::Context;
    9. using v8::FunctionCallbackInfo;
    10. using v8::Isolate;
    11. using v8::Local;
    12. using v8::Number;
    13. using v8::Object;
    14. using v8::String;
    15. using v8::Value;
    17. void CreateObject(const FunctionCallbackInfo<Value>& args) {
    18.   MyObject::NewInstance(args);
    19. }
    21. void Add(const FunctionCallbackInfo<Value>& args) {
    22.   Isolate* isolate = args.GetIsolate();
    23.   Local<Context> context = isolate->GetCurrentContext();
    25.   MyObject* obj1 = node::ObjectWrap::Unwrap<MyObject>(
    26.       args[0]->ToObject(context).ToLocalChecked());
    27.   MyObject* obj2 = node::ObjectWrap::Unwrap<MyObject>(
    28.       args[1]->ToObject(context).ToLocalChecked());
    30.   double sum = obj1->value() + obj2->value();
    31.   args.GetReturnValue().Set(Number::New(isolate, sum));
    32. }
    34. void InitAll(Local<Object> exports) {
    35.   MyObject::Init(exports->GetIsolate());
    37.   NODE_SET_METHOD(exports, "createObject", CreateObject);
    38.   NODE_SET_METHOD(exports, "add", Add);
    39. }
    41. NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)
    43. }  // namespace demo

    在 myobject.h 中，新增了一个新的公共方法用于在去包装对象后访问私有值。

    1. // myobject.h
    2. #ifndef MYOBJECT_H
    3. #define MYOBJECT_H
    5. #include <node.h>
    6. #include <node_object_wrap.h>
    8. namespace demo {
    10. class MyObject : public node::ObjectWrap {
    11.  public:
    12.   static void Init(v8::Isolate* isolate);
    13.   static void NewInstance(const v8::FunctionCallbackInfo<v8::Value>& args);
    14.   inline double value() const { return value_; }
    16.  private:
    17.   explicit MyObject(double value = 0);
    18.   ~MyObject();
    20.   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
    21.   static v8::Global<v8::Function> constructor;
    22.   double value_;
    23. };
    25. }  // namespace demo
    27. #endif

    myobject.cc 中的实现类似之前的例子：

    1. // myobject.cc
    2. #include <node.h>
    3. #include "myobject.h"
    5. namespace demo {
    7. using node::AddEnvironmentCleanupHook;
    8. using v8::Context;
    9. using v8::Function;
    10. using v8::FunctionCallbackInfo;
    11. using v8::FunctionTemplate;
    12. using v8::Global;
    13. using v8::Isolate;
    14. using v8::Local;
    15. using v8::Object;
    16. using v8::String;
    17. using v8::Value;
    19. // 注意！这不是线程安全的，此插件不能用于工作线程。
    20. Global<Function> MyObject::constructor;
    22. MyObject::MyObject(double value) : value_(value) {
    23. }
    25. MyObject::~MyObject() {
    26. }
    28. void MyObject::Init(Isolate* isolate) {
    29.   // Prepare constructor template
    30.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
    31.   tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject").ToLocalChecked());
    32.   tpl->InstanceTemplate()->SetInternalFieldCount(1);
    34.   Local<Context> context = isolate->GetCurrentContext();
    35.   constructor.Reset(isolate, tpl->GetFunction(context).ToLocalChecked());
    37.   AddEnvironmentCleanupHook(isolate, [](void*) {
    38.     constructor.Reset();
    39.   }, nullptr);
    40. }
    42. void MyObject::New(const FunctionCallbackInfo<Value>& args) {
    43.   Isolate* isolate = args.GetIsolate();
    44.   Local<Context> context = isolate->GetCurrentContext();
    46.   if (args.IsConstructCall()) {
    47.     // 像构造函数一样调用：`new MyObject(...)`
    48.     double value = args[0]->IsUndefined() ?
    49.         0 : args[0]->NumberValue(context).FromMaybe(0);
    50.     MyObject* obj = new MyObject(value);
    51.     obj->Wrap(args.This());
    52.     args.GetReturnValue().Set(args.This());
    53.   } else {
    54.     // 像普通方法 `MyObject(...)` 一样调用，转为构造调用。
    55.     const int argc = 1;
    56.     Local<Value> argv[argc] = { args[0] };
    57.     Local<Function> cons = Local<Function>::New(isolate, constructor);
    58.     Local<Object> instance =
    59.         cons->NewInstance(context, argc, argv).ToLocalChecked();
    60.     args.GetReturnValue().Set(instance);
    61.   }
    62. }
    64. void MyObject::NewInstance(const FunctionCallbackInfo<Value>& args) {
    65.   Isolate* isolate = args.GetIsolate();
    67.   const unsigned argc = 1;
    68.   Local<Value> argv[argc] = { args[0] };
    69.   Local<Function> cons = Local<Function>::New(isolate, constructor);
    70.   Local<Context> context = isolate->GetCurrentContext();
    71.   Local<Object> instance =
    72.       cons->NewInstance(context, argc, argv).ToLocalChecked();
    74.   args.GetReturnValue().Set(instance);
    75. }
    77. }  // namespace demo

    测试：

    1. // test.js
    2. const addon = require('./build/Release/addon');
    4. const obj1 = addon.createObject(10);
    5. const obj2 = addon.createObject(20);
    6. const result = addon.add(obj1, obj2);
    8. console.log(result);
    9. // 打印: 30