NodeJS和C++之间的类型转换

NodeJS和C++之间的类型转换

我非常喜欢使用 Node.js,但是当涉及到计算密集型的场景时 Node.js 就不能够很好地胜任了。而在这样的情况下 C++ 是一个很好的选择,非常幸运 Node.js 官方提供了C/C++ Addons 的机制让我们能够使用 V8 API 把 Node.js 和 C++ 结合起来。

作者:慎里来源:慎里|2016-12-20 16:35

 收藏

  分享

9月15日技术沙龙 | 与东华软件、AWS、京东金融、饿了么四位大咖探讨精准运维!

 

我非常喜欢使用 Node.js,但是当涉及到计算密集型的场景时 Node.js 就不能够很好地胜任了。而在这样的情况下 C++ 是一个很好的选择,非常幸运 Node.js 官方提供了C/C++ Addons 的机制让我们能够使用 V8 API 把 Node.js 和 C++ 结合起来。

虽然在 Node.js 官方网站有很多的关于怎么使用这些 API 的文档,但是在 JavaScript 和 C++ 之间传递数据是一件非常麻烦的事情,C++ 是强类型语言(”1024” 是字符串类型而不是整数类型),而 JavaScript 却总是默认的帮我们做一些类型转换。

JavaScript 的基本类型包括 String,Number,Boolean,null,undefined,V8 使用类继承的方式来定义这类型,这些类型都继承了 Primitive 类,而 Primitive 继承了 Value,v8 也支持整型(包括 Int32 和 Uint32),而所有的类型定义都可以从 V8 类型文档中看到,除了基本的类型,还有 Object,Array,Map 等类型的定义。

基本类型的继承关系如下图

在 V8 中所有 JavaScript 值都是被放在 Local 对象中,通过这个对象指定了 JavaScript 运行时的内存单元。

下面这段代定义了一个 Number 类型的值,其中 Test 函数中声明的 isolate 变量代表着 V8 虚拟机中的堆内存,当创建新变量的时候就需要用到它,接下来的一行代码就通过 isolate 声明了一个 Number 类型的变量。

 
  1. #include  
  2. #include  
  3.  
  4. using namespace v8; 
  5.  
  6. void Test(const v8::FunctionCallbackInfo& args) { 
  7.     Isolate* isolate = args.GetIsolate(); 
  8.     // 声明变量 
  9.     Local retval = v8::Number::New(isolate, 1000); 
  10.  
  11. void init(Local  exports, Local module) { 
  12.     NODE_SET_METHOD(exports, "getTestValue", Test); 
  13.  
  14. NODE_MODULE(returnValue, init) 
  15. 看了 V8 类型 API 文档 你会发现对于基本的 JavaScript 类型,只有变量的声明而没有变量的赋值。最初想可能觉得这个非常的奇怪,可是仔细想一想后发现这个是合理的。主要由以下几点原因:

    • JavaScript 的基本类型是不可变类型,变量都是指向一个不可变的内存单元,var a = 10,则 a 指向的内存单元中包含的值为 5,重新赋值 a = 100,没有改变这个内存单元的值,而是使得 a 指向了另外一个内存单元,其中的值为 100。如果声明两个变量 x,y 的值都为 10,则他们指向的是同一个内存单元。

    • 函数的传参都是传值,而不是传引用,当在 JavaScript 中调用 C++ 的函数时,如果参数是基本类型则每次都是把这个值拷贝过去,改变参数的值不会影响原来的值。

    • 使用 Local 声明基本类型的变量都是对内存单元的引用,因为第一条原因不可能改变引用的值使其指向另外一个内存单元,因此不存在变量的重新赋值。

    数据流向 C++ -> JavaScript

    下面 demo 定义了一些常用的 JavaScript 类型,包括基本类型的以及 Object, Array, Fuction。

     
    1. #include  
    2. #include  
    3.  
    4. using namespace v8; 
    5.  
    6. void MyFunction(const v8::FunctionCallbackInfo& args) { 
    7.     Isolate* isolate = args.GetIsolate(); 
    8.     args.GetReturnValue().Set(String::NewFromUtf8(isolate, "Hello World!")); 
    9.  
    10. void Test(const v8::FunctionCallbackInfo& args) { 
    11.     Isolate* isolate = args.GetIsolate(); 
    12.  
    13.     // Number 类型的声明 
    14.     Local retval = v8::Number::New(isolate, 1000); 
    15.  
    16.     // String 类型的声明 
    17.     Local str = v8::String::NewFromUtf8(isolate, "Hello World!"); 
    18.  
    19.     // Object 类型的声明 
    20.     Local obj = v8::Object::New(isolate); 
    21.     // 对象的赋值 
    22.     obj->Set(v8::String::NewFromUtf8(isolate, "arg1"), str); 
    23.     obj->Set(v8::String::NewFromUtf8(isolate, "arg2"), retval); 
    24.  
    25.     // Function 类型的声明并赋值 
    26.     Local tpl = v8::FunctionTemplate::New(isolate, MyFunction); 
    27.     Local fn = tpl->GetFunction(); 
    28.     // 函数名字 
    29.     fn->SetName(String::NewFromUtf8(isolate, "theFunction")); 
    30.     obj->Set(v8::String::NewFromUtf8(isolate, "arg3"), fn); 
    31.  
    32.     // Boolean 类型的声明 
    33.     Local flag = Boolean::New(isolate, true); 
    34.     obj->Set(String::NewFromUtf8(isolate, "arg4"), flag); 
    35.  
    36.     // Array 类型的声明 
    37.     Local arr = Array::New(isolate); 
    38.     // Array 赋值 
    39.     arr->Set(0, Number::New(isolate, 1)); 
    40.     arr->Set(1, Number::New(isolate, 10)); 
    41.     arr->Set(2, Number::New(isolate, 100)); 
    42.     arr->Set(3, Number::New(isolate, 1000)); 
    43.     obj->Set(String::NewFromUtf8(isolate, "arg5"), arr); 
    44.  
    45.     // Undefined 类型的声明 
    46.     Local und = Undefined(isolate); 
    47.     obj->Set(String::NewFromUtf8(isolate, "arg6"), und); 
    48.  
    49.     // null 类型的声明 
    50.     Local null = Null(isolate); 
    51.     obj->Set(String::NewFromUtf8(isolate, "arg7"), null); 
    52.  
    53.     // 返回给 JavaScript 调用时的返回值 
    54.     args.GetReturnValue().Set(obj); 
    55.  
    56. void init(Local  exports, Local module) { 
    57.     NODE_SET_METHOD(exports, "getTestValue", Test); 
    58.  
    59. NODE_MODULE(returnValue, init) 
    60. 所有的 addon 都需要一个初始化的函数,如下面的代码:

      void Initialize(Local exports);
      NODE_MODULE(module_name, Initialize)

      Initialize 是初始化的函数,module_name 是编译后产生的二进制文件名,上述代码的模块名为returnValue

      上述代码通过 node-gyp 编译后(编译过程官方文档 C/C++ Addons 有详细的介绍),可以通过如下的方式调用。

      // returnValue.node 这个文件就是编译后产生的文件,通过 NODE_MODULE(returnValue, init) 决定的文件名
      const returnValue = require('./build/Release/returnValue.node');
      console.log(returnValue.getTestValue());

      运行结果如下:

      数据流向 javaScript -> C++

      上面的 demo 展示了怎样在在 C++ 定义 JavaScript 类型,数据的是从 C++ 流向 JavaScript,反过来数据也需要从 javaScript 流向 C++,也就是调用 C++ 函数的时候需要传入一些参数。

      下面的代码展示了参数个数判断,参数类型判断,以及参数类型装换成 V8 类型的过程,包括基本类型以及 Object, Array, Fuction。

       
      1. #include  
      2. #include  
      3. #include  
      4.  
      5. using namespace v8; 
      6. using namespace std; 
      7.  
      8. void GetArgument(const FunctionCallbackInfo& args) { 
      9.     Isolate* isolate = args.GetIsolate(); 
      10.  
      11.     // 参数长度判断 
      12.     if (args.Length() < 2) { 
      13.         isolate->ThrowException(Exception::TypeError( 
      14.             String::NewFromUtf8(isolate, "Wrong number of arguments"))); 
      15.         return; 
      16.     } 
      17.  
      18.     // 参数类型判断 
      19.     if (!args[0]->IsNumber() || !args[1]->IsNumber()) { 
      20.         //抛出错误 
      21.         isolate->ThrowException(Exception::TypeError( 
      22.             String::NewFromUtf8(isolate, "argumnets must be number"))); 
      23.     } 
      24.  
      25.     if (!args[0]->IsObject()) { 
      26.         printf("I am not Object\n"); 
      27.     } 
      28.  
      29.     if (!args[0]->IsBoolean()) { 
      30.         printf("I am not Boolean\n"); 
      31.     } 
      32.  
      33.     if (!args[0]->IsArray()) { 
      34.         printf("I am not Array\n"); 
      35.     } 
      36.  
      37.     if (!args[0]->IsString()) { 
      38.         printf("I am not String\n"); 
      39.     } 
      40.  
      41.     if (!args[0]->IsFunction()) { 
      42.         printf("I am not Function\n"); 
      43.     } 
      44.  
      45.     if (!args[0]->IsNull()) { 
      46.         printf("I am not Null\n"); 
      47.     } 
      48.  
      49.     if (!args[0]->IsUndefined()) { 
      50.         printf("I am not Undefined\n"); 
      51.     } 
      52.  
      53.     // js Number 类型转换成 v8 Number 类型 
      54.     Local value1 = Local::Cast(args[0]); 
      55.     Local value2 = Local::Cast(args[1]); 
      56.     double value = value1->NumberValue() + value2->NumberValue(); 
      57.  
      58.     // js String 类型转换成 v8 String 类型 
      59.     Local str = Local::Cast(args[2]); 
      60.     String::Utf8Value utfValue(str); 
      61.     cout<
      62.  
      63.     // js Array 类型转换成 v8 Array 类型 
      64.     Local input_array = Local::Cast(args[3]); 
      65.     printf("%d, %f %f\n", input_array->Length(), input_array->Get(0)->NumberValue(), input_array->Get(1)->NumberValue()); 
      66.  
      67.     // js Object 类型转换成 v8 Object 类型 
      68.     Local obj = Local::Cast(args[4]); 
      69.  
      70.     // 根据 key 获取对象中的值 
      71.     Local a = obj->Get(String::NewFromUtf8(isolate, "a")); 
      72.     Local b = obj->Get(String::NewFromUtf8(isolate, "b")); 
      73.  
      74.     // js Array 类型转换成 v8 Array 类型 
      75.     Local c = Local::Cast(obj->Get(String::NewFromUtf8(isolate, "c"))); 
      76.     cout<NumberValue()<<"   "<NumberValue()<
      77.     printf("%d, %f %f\n", c->Length(), c->Get(0)->NumberValue(), c->Get(1)->NumberValue()); 
      78.  
      79.     // js String 类型转换成 v8 String 类型 
      80.     Local cString = Local::Cast(c->Get(2)); 
      81.     String::Utf8Value utfValueD(cString); 
      82.     cout<
      83.  
      84.     // 根据 key 获取对象中的值 
      85.     Local d = Local::Cast(obj->Get(String::NewFromUtf8(isolate, "d"))); 
      86.     Local dString1 = Local::Cast(d->Get(String::NewFromUtf8(isolate, "m"))); 
      87.     String::Utf8Value utfValued1(dString1); 
      88.     cout<
      89.  
      90.     // 根据 key 获取对象中的值 
      91.     Local dString2 = Local::Cast(d->Get(String::NewFromUtf8(isolate, "n"))); 
      92.     String::Utf8Value utfValued2(dString2); 
      93.     cout<
      94.  
      95.     // js Booelan 类型转换成 v8 Boolean 类型 
      96.     Local FlagTrue = Local::Cast(args[5]); 
      97.     cout<<"Flag: "<BooleanValue()<
      98.  
      99.     // js Function 类型转换成 v8 Function 类型 
      100.     Local cb = Local::Cast(args[8]); 
      101.     const unsigned argc = 2; 
      102.     Local argv[2]; 
      103.     argv[0] = a; 
      104.     argv[1] = b; 
      105.     cb->Call(Null(isolate), argc, argv); 
      106.  
      107.     args.GetReturnValue().Set(value); 
      108.  
      109. void Init(Local  exports, Local  module) { 
      110.     NODE_SET_METHOD(module, "exports", GetArgument); 
      111.  
      112. NODE_MODULE(argumentss, Init) 
      113. 通过 node-gyp 编译后,可以通过如下的方式调用。

         
        1. const getArguments = require('./build/Release/arguments'); 
        2.  
        3. console.log(getArguments(2, 3, 'Hello Arguments', [1, 2, 3], { 
        4.         a: 10, 
        5.         b: 100, 
        6.         c: [23, 22, "我是33"], 
        7.         d: { m: '我是22', n: '我是23' } 
        8.     }, true, null, undefined, 
        9.     function myFunction(...args) { 
        10.         console.log('I am Function!'); 
        11.         console.log(...args); 
        12.         console.log('I am Function!'); 
        13.     })); 

        运行结果如下:

        关于其他的类型,我这里就就不一一介绍,V8 文档里面都有对应的 API。

        NAN

        由于 V8 的 API 还没有彻底稳定下来,所以对于不同版本的 Node.js 类型相关的 API 会发生变化,而 NAN 帮我们做了封装,在编码的时候不需要关心版本问题,只需要引入相应的头文件即可。

        引入头文件后,可以如下使用方式:

        v8::Local Nan::Undefined()
        v8::Local Nan::Null()

        参考资料

        • Type conversions from JavaScript to C++ in V8

        • node addon

        • v8 types documentation

        • node-gyp

        • gyp user documentation

        • nan

        你可能感兴趣的:(NodeJS和C++之间的类型转换)