NodeJS和C++之間的類型轉換

作者：慎里 2016-12-07 11:23:52

雖然在 Node.js 官方網站有很多的關于怎么使用這些 API 的文檔，但是在 JavaScript 和 C++ 之間傳遞數據是一件非常麻煩的事情，C++ 是強類型語言（”1024” 是字符串類型而不是整數類型），而 JavaScript 卻總是默認的幫我們做一些類型轉換。

我非常喜歡使用 Node.js，但是當涉及到計算密集型的場景時 Node.js 就不能夠很好地勝任了。而在這樣的情況下 C++ 是一個很好的選擇，非常幸運 Node.js 官方提供了C/C++ Addons 的機制讓我們能夠使用 V8 API 把 Node.js 和 C++ 結合起來。

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 類型的變量。

#include <node.h> 
#include <v8.h> 
 
using namespace v8; 
 
void Test(const v8::FunctionCallbackInfo<v8::Value>& args) { 
    Isolate* isolate = args.GetIsolate(); 
    // 聲明變量 
    Local<Number> retval = v8::Number::New(isolate, 1000); 
} 
 
void init(Local <Object> exports, Local<Object> module) { 
    NODE_SET_METHOD(exports, "getTestValue", Test); 
} 
 
NODE_MODULE(returnValue, init)

看了 V8 類型 API 文檔你會發現對于基本的 JavaScript 類型，只有變量的聲明而沒有變量的賦值。最初想可能覺得這個非常的奇怪，可是仔細想一想后發現這個是合理的。主要由以下幾點原因：

JavaScript 的基本類型是不可變類型，變量都是指向一個不可變的內存單元，var a = 10，則 a 指向的內存單元中包含的值為 5，重新賦值 a = 100，沒有改變這個內存單元的值，而是使得 a 指向了另外一個內存單元，其中的值為 100。如果聲明兩個變量 x，y 的值都為 10，則他們指向的是同一個內存單元。
函數的傳參都是傳值，而不是傳引用，當在 JavaScript 中調用 C++ 的函數時，如果參數是基本類型則每次都是把這個值拷貝過去，改變參數的值不會影響原來的值。
使用 Local<Value> 聲明基本類型的變量都是對內存單元的引用，因為***條原因不可能改變引用的值使其指向另外一個內存單元，因此不存在變量的重新賦值。

數據流向 C++ -> JavaScript

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

#include <node.h> 
#include <v8.h> 
 
using namespace v8; 
 
void MyFunction(const v8::FunctionCallbackInfo<Value>& args) { 
    Isolate* isolate = args.GetIsolate(); 
    args.GetReturnValue().Set(String::NewFromUtf8(isolate, "Hello World!")); 
} 
 
void Test(const v8::FunctionCallbackInfo<v8::Value>& args) { 
    Isolate* isolate = args.GetIsolate(); 
 
    // Number 類型的聲明 
    Local<Number> retval = v8::Number::New(isolate, 1000); 
 
    // String 類型的聲明 
    Local<String> str = v8::String::NewFromUtf8(isolate, "Hello World!"); 
 
    // Object 類型的聲明 
    Local<Object> obj = v8::Object::New(isolate); 
    // 對象的賦值 
    obj->Set(v8::String::NewFromUtf8(isolate, "arg1"), str); 
    obj->Set(v8::String::NewFromUtf8(isolate, "arg2"), retval); 
 
    // Function 類型的聲明并賦值 
    Local<FunctionTemplate> tpl = v8::FunctionTemplate::New(isolate, MyFunction); 
    Local<Function> fn = tpl->GetFunction(); 
    // 函數名字 
    fn->SetName(String::NewFromUtf8(isolate, "theFunction")); 
    obj->Set(v8::String::NewFromUtf8(isolate, "arg3"), fn); 
 
    // Boolean 類型的聲明 
    Local<Boolean> flag = Boolean::New(isolate, true); 
    obj->Set(String::NewFromUtf8(isolate, "arg4"), flag); 
 
    // Array 類型的聲明 
    Local<Array> arr = Array::New(isolate); 
    // Array 賦值 
    arr->Set(0, Number::New(isolate, 1)); 
    arr->Set(1, Number::New(isolate, 10)); 
    arr->Set(2, Number::New(isolate, 100)); 
    arr->Set(3, Number::New(isolate, 1000)); 
    obj->Set(String::NewFromUtf8(isolate, "arg5"), arr); 
 
    // Undefined 類型的聲明 
    Local<Value> und = Undefined(isolate); 
    obj->Set(String::NewFromUtf8(isolate, "arg6"), und); 
 
    // null 類型的聲明 
    Local<Value> null = Null(isolate); 
    obj->Set(String::NewFromUtf8(isolate, "arg7"), null); 
 
    // 返回給 JavaScript 調用時的返回值 
    args.GetReturnValue().Set(obj); 
} 
 
void init(Local <Object> exports, Local<Object> module) { 
    NODE_SET_METHOD(exports, "getTestValue", Test); 
} 
 
NODE_MODULE(returnValue, init)

所有的 addon 都需要一個初始化的函數，如下面的代碼：

void Initialize(Local<Object> 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。

#include <node.h> 
#include <v8.h> 
#include <iostream> 
 
using namespace v8; 
using namespace std; 
 
void GetArgument(const FunctionCallbackInfo<Value>& 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, "argumnets must be number"))); 
    } 
 
    if (!args[0]->IsObject()) { 
        printf("I am not Object\n"); 
    } 
 
    if (!args[0]->IsBoolean()) { 
        printf("I am not Boolean\n"); 
    } 
 
    if (!args[0]->IsArray()) { 
        printf("I am not Array\n"); 
    } 
 
    if (!args[0]->IsString()) { 
        printf("I am not String\n"); 
    } 
 
    if (!args[0]->IsFunction()) { 
        printf("I am not Function\n"); 
    } 
 
    if (!args[0]->IsNull()) { 
        printf("I am not Null\n"); 
    } 
 
    if (!args[0]->IsUndefined()) { 
        printf("I am not Undefined\n"); 
    } 
 
    // js Number 類型轉換成 v8 Number 類型 
    Local<Number> value1 = Local<Number>::Cast(args[0]); 
    Local<Number> value2 = Local<Number>::Cast(args[1]); 
    double value = value1->NumberValue() + value2->NumberValue(); 
 
    // js String 類型轉換成 v8 String 類型 
    Local<String> str = Local<String>::Cast(args[2]); 
    String::Utf8Value utfValue(str); 
    cout<<string(*utfValue)<<endl; 
 
    // js Array 類型轉換成 v8 Array 類型 
    Local<Array> input_array = Local<Array>::Cast(args[3]); 
    printf("%d, %f %f\n", input_array->Length(), input_array->Get(0)->NumberValue(), input_array->Get(1)->NumberValue()); 
 
    // js Object 類型轉換成 v8 Object 類型 
    Local<Object> obj = Local<Object>::Cast(args[4]); 
 
    // 根據 key 獲取對象中的值 
    Local<Value> a = obj->Get(String::NewFromUtf8(isolate, "a")); 
    Local<Value> b = obj->Get(String::NewFromUtf8(isolate, "b")); 
 
    // js Array 類型轉換成 v8 Array 類型 
    Local<Array> c = Local<Array>::Cast(obj->Get(String::NewFromUtf8(isolate, "c"))); 
    cout<<a->NumberValue()<<"   "<<b->NumberValue()<<endl; 
    printf("%d, %f %f\n", c->Length(), c->Get(0)->NumberValue(), c->Get(1)->NumberValue()); 
 
    // js String 類型轉換成 v8 String 類型 
    Local<String> cString = Local<String>::Cast(c->Get(2)); 
    String::Utf8Value utfValueD(cString); 
    cout<<string(*utfValueD)<<endl; 
 
    // 根據 key 獲取對象中的值 
    Local<Object> d = Local<Object>::Cast(obj->Get(String::NewFromUtf8(isolate, "d"))); 
    Local<String> dString1 = Local<String>::Cast(d->Get(String::NewFromUtf8(isolate, "m"))); 
    String::Utf8Value utfValued1(dString1); 
    cout<<string(*utfValued1)<<endl; 
 
    // 根據 key 獲取對象中的值 
    Local<String> dString2 = Local<String>::Cast(d->Get(String::NewFromUtf8(isolate, "n"))); 
    String::Utf8Value utfValued2(dString2); 
    cout<<string(*utfValued2)<<endl; 
 
    // js Booelan 類型轉換成 v8 Boolean 類型 
    Local<Boolean> FlagTrue = Local<Boolean>::Cast(args[5]); 
    cout<<"Flag: "<<FlagTrue->BooleanValue()<<endl; 
 
    // js Function 類型轉換成 v8 Function 類型 
    Local<Function> cb = Local<Function>::Cast(args[8]); 
    const unsigned argc = 2; 
    Local<Value> argv[2]; 
    argv[0] = a; 
    argv[1] = b; 
    cb->Call(Null(isolate), argc, argv); 
 
    args.GetReturnValue().Set(value); 
} 
 
void Init(Local <Object> exports, Local <Object> module) { 
    NODE_SET_METHOD(module, "exports", GetArgument); 
} 
 
NODE_MODULE(argumentss, Init)

運行結果如下:

[[178264]]

關于其他的類型，我這里就就不一一介紹，V8 文檔里面都有對應的 API。

NAN

由于 V8 的 API 還沒有徹底穩定下來，所以對于不同版本的 Node.js 類型相關的 API 會發生變化，而 NAN 幫我們做了封裝，在編碼的時候不需要關心版本問題，只需要引入相應的頭文件即可。

引入頭文件后，可以如下使用方式：

v8::Local<v8::Primitive> Nan::Undefined()
v8::Local<v8::Primitive> Nan::Null()

參考資料

Type conversions from JavaScript to C++ in V8
node addon
v8 types documentation
node-gyp
gyp user documentation
nan

責任編輯：張燕妮來源：慎里

NodeJS C++

国产精品电影_久久视频免费_欧美日韩国产激情_成年人视频免费在线播放_日本久久亚洲电影_久久都是精品_66av99_九色精品美女在线_蜜臀a∨国产成人精品_冲田杏梨av在线_欧美精品在线一区二区三区_麻豆mv在线看

NodeJS和C++之間的類型轉換