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

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

       
 
        
  
  
      1. void Initialize(Local exports); 
  
  
      2. NODE_MODULE(module_name, Initialize) 
        3. 
 
 
        Initialize 是初始化的函数，module_name 是编译后产生的二进制文件名，上述代码的模块名为returnValue。
        上述代码通过 node-gyp 编译后（编译过程官方文档 C/C++ Addons 有详细的介绍），可以通过如下的方式调用。
         
        

         
 
          
  
  
        1. // returnValue.node 这个文件就是编译后产生的文件，通过 NODE_MODULE(returnValue, init) 决定的文件名 
          2. 
  
  
        2. const returnValue = require('./build/Release/returnValue.node'); 
          3. 
  
  
        3. console.log(returnValue.getTestValue()); 
          4. 
 
 
        运行结果如下:
        数据流向 javaScript -> C++
        上面的 demo 展示了怎样在在 C++ 定义 JavaScript 类型，数据的是从 C++ 流向 JavaScript，反过来数据也需要从 javaScript 流向 C++，也就是调用 C++ 函数的时候需要传入一些参数。
        下面的代码展示了参数个数判断，参数类型判断，以及参数类型装换成 V8 类型的过程，包括基本类型以及 Object, Array, Fuction。
        

         
 
          
  
  
        1. #include  
          2. 
  
  
        2. #include  
          3. 
  
  
        3. #include  
          4. 
  
  
        4.  
          5. 
  
  
        5. using namespace v8; 
          6. 
  
  
        6. using namespace std; 
          7. 
  
  
        7.  
          8. 
  
  
        8. void GetArgument(const FunctionCallbackInfo& args) { 
          9. 
  
  
        9.     Isolate* isolate = args.GetIsolate(); 
          10. 
  
  
        10.  
          11. 
  
  
        11.     // 参数长度判断 
          12. 
  
  
        12.     if (args.Length() < 2) { 
          13. 
  
  
        13.         isolate->ThrowException(Exception::TypeError( 
          14. 
  
  
        14.             String::NewFromUtf8(isolate, "Wrong number of arguments"))); 
          15. 
  
  
        15.         return; 
          16. 
  
  
        16.     } 
          17. 
  
  
        17.  
          18. 
  
  
        18.     // 参数类型判断 
          19. 
  
  
        19.     if (!args[0]->IsNumber() || !args[1]->IsNumber()) { 
          20. 
  
  
        20.         //抛出错误 
          21. 
  
  
        21.         isolate->ThrowException(Exception::TypeError( 
          22. 
  
  
        22.             String::NewFromUtf8(isolate, "argumnets must be number"))); 
          23. 
  
  
        23.     } 
          24. 
  
  
        24.  
          25. 
  
  
        25.     if (!args[0]->IsObject()) { 
          26. 
  
  
        26.         printf("I am not Object\n"); 
          27. 
  
  
        27.     } 
          28. 
  
  
        28.  
          29. 
  
  
        29.     if (!args[0]->IsBoolean()) { 
          30. 
  
  
        30.         printf("I am not Boolean\n"); 
          31. 
  
  
        31.     } 
          32. 
  
  
        32.  
          33. 
  
  
        33.     if (!args[0]->IsArray()) { 
          34. 
  
  
        34.         printf("I am not Array\n"); 
          35. 
  
  
        35.     } 
          36. 
  
  
        36.  
          37. 
  
  
        37.     if (!args[0]->IsString()) { 
          38. 
  
  
        38.         printf("I am not String\n"); 
          39. 
  
  
        39.     } 
          40. 
  
  
        40.  
          41. 
  
  
        41.     if (!args[0]->IsFunction()) { 
          42. 
  
  
        42.         printf("I am not Function\n"); 
          43. 
  
  
        43.     } 
          44. 
  
  
        44.  
          45. 
  
  
        45.     if (!args[0]->IsNull()) { 
          46. 
  
  
        46.         printf("I am not Null\n"); 
          47. 
  
  
        47.     } 
          48. 
  
  
        48.  
          49. 
  
  
        49.     if (!args[0]->IsUndefined()) { 
          50. 
  
  
        50.         printf("I am not Undefined\n"); 
          51. 
  
  
        51.     } 
          52. 
  
  
        52.  
          53. 
  
  
        53.     // js Number 类型转换成 v8 Number 类型 
          54. 
  
  
        54.     Local value1 = Local::Cast(args[0]); 
          55. 
  
  
        55.     Local value2 = Local::Cast(args[1]); 
          56. 
  
  
        56.     double value = value1->NumberValue() + value2->NumberValue(); 
          57. 
  
  
        57.  
          58. 
  
  
        58.     // js String 类型转换成 v8 String 类型 
          59. 
  
  
        59.     Local str = Local::Cast(args[2]); 
          60. 
  
  
        60.     String::Utf8Value utfValue(str); 
          61. 
  
  
        61.     cout<
  
  
        62.  
          63. 
  
  
        63.     // js Array 类型转换成 v8 Array 类型 
          64. 
  
  
        64.     Local input_array = Local::Cast(args[3]); 
          65. 
  
  
        65.     printf("%d, %f %f\n", input_array->Length(), input_array->Get(0)->NumberValue(), input_array->Get(1)->NumberValue()); 
          66. 
  
  
        66.  
          67. 
  
  
        67.     // js Object 类型转换成 v8 Object 类型 
          68. 
  
  
        68.     Local obj = Local::Cast(args[4]); 
  
  
        69.  
          70. 
  
  
        70.     // 根据 key 获取对象中的值 
          71. 
  
  
        71.     Local a = obj->Get(String::NewFromUtf8(isolate, "a")); 
          72. 
  
  
        72.     Local b = obj->Get(String::NewFromUtf8(isolate, "b")); 
          73. 
  
  
        73.  
          74. 
  
  
        74.     // js Array 类型转换成 v8 Array 类型 
          75. 
  
  
        75.     Local c = Local::Cast(obj->Get(String::NewFromUtf8(isolate, "c"))); 
          76. 
  
  
        76.     cout<NumberValue()<<"   "<NumberValue()<
  
  
        77.     printf("%d, %f %f\n", c->Length(), c->Get(0)->NumberValue(), c->Get(1)->NumberValue()); 
          78. 
  
  
        78.  
          79. 
  
  
        79.     // js String 类型转换成 v8 String 类型 
          80. 
  
  
        80.     Local cString = Local::Cast(c->Get(2)); 
          81. 
  
  
        81.     String::Utf8Value utfValueD(cString); 
          82. 
  
  
        82.     cout<
  
  
        83.  
          84. 
  
  
        84.     // 根据 key 获取对象中的值 
          85. 
  
  
        85.     Local d = Local::Cast(obj->Get(String::NewFromUtf8(isolate, "d"))); 
  
  
        86.     Local dString1 = Local::Cast(d->Get(String::NewFromUtf8(isolate, "m"))); 
          87. 
  
  
        87.     String::Utf8Value utfValued1(dString1); 
          88. 
  
  
        88.     cout<
  
  
        89.  
          90. 
  
  
        90.     // 根据 key 获取对象中的值 
          91. 
  
  
        91.     Local dString2 = Local::Cast(d->Get(String::NewFromUtf8(isolate, "n"))); 
          92. 
  
  
        92.     String::Utf8Value utfValued2(dString2); 
          93. 
  
  
        93.     cout<
  
  
        94.  
          95. 
  
  
        95.     // js Booelan 类型转换成 v8 Boolean 类型 
          96. 
  
  
        96.     Local FlagTrue = Local::Cast(args[5]); 
          97. 
  
  
        97.     cout<<"Flag: "<BooleanValue()<
  
  
        98.  
          99. 
  
  
        99.     // js Function 类型转换成 v8 Function 类型 
          100. 
  
  
        100.     Local cb = Local::Cast(args[8]); 
          101. 
  
  
        101.     const unsigned argc = 2; 
          102. 
  
  
        102.     Local argv[2]; 
          103. 
  
  
        103.     argv[0] = a; 
          104. 
  
  
        104.     argv[1] = b; 
          105. 
  
  
        105.     cb->Call(Null(isolate), argc, argv); 
          106. 
  
  
        106.  
          107. 
  
  
        107.     args.GetReturnValue().Set(value); 
          108. 
  
  
        108. } 
          109. 
  
  
        109.  
          110. 
  
  
        110. void Init(Local  exports, Local  module) { 
  
  
        111.     NODE_SET_METHOD(module, "exports", GetArgument); 
          112. 
  
  
        112. } 
          113. 
  
  
        113.  
          114. 
  
  
        114. NODE_MODULE(argumentss, Init) 
          115. 
 
 
          运行结果如下:
          关于其他的类型，我这里就就不一一介绍，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++之间的类型转换
                
          
                当前URL：http://www.shufengxianlan.com/qtweb/news40/242390.html
            
          
            
          
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
          
            
          
                广告
                
            
          
            
          
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
          
        
        
          
            
          猜你还喜欢下面的内容
          
            
        
          
    
    
          
        
          
            
          网站排名知识
          
            
        
          
        
          
            
          分类信息网
          
            
        
          
    
          


          
    
          
        做网站价格　　 　成都网站推广营销　　 　成都网站制作　　 　成都气球装饰　　 　seo推广公司　　 　微信开发　　 　盐亭网站建设　　 　网站营销　　 　宜宾做网站　　 　自适应网页设计　　 　四川主机托管　　 　重庆网站制作　　 　微信小程序　　 　手机网站建设　　 　重庆服务器托管　　 　正泰动物　　 　成都网站建设　　 　新网创想　　 　H5网站制作　　 　四川正泰动物