Node.js 和 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 类型的变量。

#include

#include

usingnamespace v8;

void Test(const v8::FunctionCallbackInfo & args) {

Isolate* isolate = args.GetIsolate();

// 声明变量

Local retval = v8::Number::New(isolate, 1000);

}

void init(Local exports, Local 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 声明基本类型的变量都是对内存单元的引用，因为第一条原因不可能改变引用的值使其指向另外一个内存单元，因此不存在变量的重新赋值。

数据流向 C++ -> JavaScript

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

#include

#include

usingnamespace v8;

void MyFunction(const v8::FunctionCallbackInfo & args) {

Isolate* isolate = args.GetIsolate();

args.GetReturnValue().Set(String::NewFromUtf8(isolate, "Hello World!"));

}

void Test(const v8::FunctionCallbackInfo & args) {

Isolate* isolate = args.GetIsolate();

// Number 类型的声明

Local retval = v8::Number::New(isolate, 1000);

// String 类型的声明

Local str = v8::String::NewFromUtf8(isolate, "Hello World!");

// Object 类型的声明

Local obj = v8::Object::New(isolate);

// 对象的赋值

obj->Set(v8::String::NewFromUtf8(isolate, "arg1"), str);

obj->Set(v8::String::NewFromUtf8(isolate, "arg2"), retval);

// Function 类型的声明并赋值

Local tpl = v8::FunctionTemplate::New(isolate, MyFunction);

Local fn = tpl->GetFunction();

// 函数名字

fn->SetName(String::NewFromUtf8(isolate, "theFunction"));

obj->Set(v8::String::NewFromUtf8(isolate, "arg3"), fn);

// Boolean 类型的声明

Local flag = Boolean::New(isolate, true);

obj->Set(String::NewFromUtf8(isolate, "arg4"), flag);

// Array 类型的声明

Local 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 und = Undefined(isolate);

obj->Set(String::NewFromUtf8(isolate, "arg6"), und);

// null 类型的声明

Local null = Null(isolate);

obj->Set(String::NewFromUtf8(isolate, "arg7"), null);

// 返回给 JavaScript 调用时的返回值

args.GetReturnValue().Set(obj);

}

void init(Local exports, Local module) {

NODE_SET_METHOD(exports, "getTestValue", Test);

}

NODE_MODULE(returnValue, init)

所有的 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。

#include

#include

#include

usingnamespace v8;

usingnamespace std;

void GetArgument(const FunctionCallbackInfo & 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 value1 = Local ::Cast(args[0]);

Local value2 = Local ::Cast(args[1]);

double value = value1->NumberValue() + value2->NumberValue();

// js String 类型转换成 v8 String 类型

Local str = Local ::Cast(args[2]);

String::Utf8ValueutfValue(str);

cout<

// js Array 类型转换成 v8 Array 类型

Local input_array = Local ::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 obj = Local ::Cast(args[4]);

// 根据 key 获取对象中的值

Local a = obj->Get(String::NewFromUtf8(isolate, "a"));

Local b = obj->Get(String::NewFromUtf8(isolate, "b"));

// js Array 类型转换成 v8 Array 类型

Local c = Local ::Cast(obj->Get(String::NewFromUtf8(isolate, "c")));

cout< NumberValue()<<"   "< NumberValue()<

printf("%d, %f %f\n", c->Length(), c->Get(0)->NumberValue(), c->Get(1)->NumberValue());

// js String 类型转换成 v8 String 类型

Local cString = Local ::Cast(c->Get(2));

String::Utf8ValueutfValueD(cString);

cout<

// 根据 key 获取对象中的值

Local d = Local ::Cast(obj->Get(String::NewFromUtf8(isolate, "d")));

Local dString1 = Local ::Cast(d->Get(String::NewFromUtf8(isolate, "m")));

String::Utf8ValueutfValued1(dString1);

cout<

// 根据 key 获取对象中的值

Local dString2 = Local ::Cast(d->Get(String::NewFromUtf8(isolate, "n")));

String::Utf8ValueutfValued2(dString2);

cout<

// js Booelan 类型转换成 v8 Boolean 类型

Local FlagTrue = Local ::Cast(args[5]);

cout<<"Flag: "< BooleanValue()<

// js Function 类型转换成 v8 Function 类型

Local cb = Local ::Cast(args[8]);

const unsigned argc = 2;

Local argv[2];

argv[0] = a;

argv[1] = b;

cb->Call(Null(isolate), argc, argv);

args.GetReturnValue().Set(value);

}

void Init(Local exports, Local module) {

NODE_SET_METHOD(module, "exports", GetArgument);

}

NODE_MODULE(argumentss, Init)

通过 node-gyp 编译后，可以通过如下的方式调用。

const getArguments = require(’./build/Release/arguments’);

console.log(getArguments(2, 3, ’Hello Arguments’, [1, 2, 3], {

a: 10,

b: 100,

c: [23, 22, "我是33"],

d: { m: ’我是22’, n: ’我是23’ }

}, true, null, undefined,

function myFunction(...args) {

console.log(’I am Function!’);

console.log(...args);

console.log(’I am Function!’);

}));

运行结果如下:

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

NAN

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

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

v8::LocalNan::Undefined()v8::LocalNan::Null()

来源：伯乐在线

时间： 2024-12-15 22:39:33

Node.js 和 C++ 之间的类型转换的相关文章

node.js笔记——文件之间的引入

node.js的基础语法就是JavaScript的语法,所以对于懂得javascript的同学来说要容易一些,至于环境的配置也要相对简单很多,可以访问官方文档进行安装.这里分享一下我在学习中总结的一些东西,这是第一篇先来说说文件之间如何进行引入并互相使用变量及函数. 码缘»node.js笔记——文件之间的引入 http://www.ithome.ren/2017/05/31/node-js1.html

node.js 多异步之间的协作方案

<深入浅出node.js> P77 学习 ///用于处理多个事件对应一个侦听器的情况var count = 0; var results = {}; var done = function (key, value){ results[key] = value; count++; if (count === 3){ ///渲染页面 render(results); } }; fs.readFile(template_path, "utf8", function(err, te

Node.js入门：异步IO

异步IO 在操作系统中,程序运行的空间分为内核空间和用户空间.我们常常提起的异步I/O,其实质是用户空间中的程序不用依赖内核空间中的I/O操作实际完成,即可进行后续任务. 同步IO的并行模式 多线程单进程    多线程的设计之处就是为了在共享的程序空间中,实现并行处理任务,从而达到充分利用CPU的效果.多线程的缺点在于执行时上下文交换的开销较大,和状态同步(锁)的问题.同样它也使得程序的编写和调用复杂化. 单线程多进程 为了避免多线程造成的使用不便问题,有的语言选择了单线程保持调用简单化,采用启

《基于Node.js实现简易聊天室系列之总结》

前前后后完成这个聊天室的Demo花了大概一个星期,当然一个星期是仅仅指编码的工作.前期的知识储备是从0到1从无到有,花费了一定的时间熟悉Node.js的基本语法以及Node.js和mongoDB之间的交互的过程.Demo中的重难点是socket.io的运行机制,从将socket.io绑定到服务器server上,到服务器和客户端双方都利用emit和on方法进行自定事件的处理.下面分别着重就上述几点进行讲解. Node.js Node.js创建服务器以及执行类似后台语言的操作.最近,也在接触C#,在

node.js与redis

最近在学习node创建项目,因为一直在用像mysql这样的结构型数据库,想学点新的东西,所以就把数据库换成了redis.redis是非关系型数据库.那关系型数据库跟非关系型数据库有什么区别呢?简单地说,就是一个有表的概念,一个没有.具体的区别自行Google吧.这里我主要介绍一下node.js与redis之间建立连接的过程,就是说如何早node:里面操作redis'数据库.因此,默认你已经装好这两个软件了. 第一步,我们需要打开redis的服务器.打开命令行,切换到redis安装目录,输入命令:

node.js JS对象和JSON字符串之间的转换

JSON.stringify(obj)将JS对象转为字符串. var json = { aa: ['sdddssd'],   bb: [ '892394829342394792399', '23894723984729374932874' ],   cc: ['11111111111111'] } => var string = JSON.stringify(json) string: {"aa":["sdddssd"],"bb":[&qu

PHP vs Node.js

网络正在处于一个日新月异的发展时代.服务器端开发人员在选择语言的时候非常困惑,有长期占主导地位的语言,例如C.Java和Perl,也有专注于web开发的语言,例如Ruby.Clojure和Go.只要你的项目运行良好,你的选择就显得没有那么重要了. 但是如何让这些新的web开发人员做出一个正确的选择呢? 我不希望展开一场PHP.NodeJs两大阵营之间的战争,我将会对比这两种语言所在领域的发展状况: PHPRasmus Lerdorf在1994年创造出了PHP.它是由安装在web服务器(Apach

为什么我这个 Java 死忠倒向了 Node.js？

作为一个在Sun微系统公司Java SE团队工作了十多年的人,难道不应该是体内流淌着Java字节码的血.只要一息尚存就要不断实现抽象接口吗?但对于我这个前Java SE团队成员来说,2011年学习了Node.js平台后就像是呼吸到了新鲜空气一样--我在2009年1月被Sun裁退之后(正好在Oracle收购之前),开始学习Node.js并被它深深所吸引. 我是怎样被吸引的?从2010年起,我就开始写各种关于Node.js编程的东西了.具体来说,写了四版<Node.js Web开发>,加上一些其他

第一节：Node.js简介

1.什么是Node.js? Node.js是一个用于开发各种Web服务器的开发工具,仔Node.js服务器中,运行的高性能V8 JavaScript脚本语言,该语言是一种可以运行仔服务器端的JavaScript脚本语言.它为了提高性能,采用了以下两种机制:非阻塞型I/O和事件环,由于采用了非阻塞型I/O,所以在执行了访问数据库的代码后将立即转而执行其后的代码,把数据库返回结果的处理代码放在回掉函数中执行,从而提高了程序的执行效率,在Node.js中,在一个时刻只能执行一个事件回掉函数,但是在执行