Google V8 引擎使用
V8 引擎是 Google 的一個開源項目，是一個高效的 JavaScript 引擎，它可以作爲一個獨立的庫被嵌入到已有的 C++ 應用之中，爲軟件的靈活性，擴展性提供可能。使用 V8 的另外一個好處是，你不需要重新學習一本腳本語言，JavaScript 已經廣泛的被開發人員，尤其是前端開發人員所使用。
V8 引擎概覽
V8 引擎簡介
Google V8 引擎使用 C++ 代碼編寫，實現了 ECMAScript 規範的第五版，可以運行在所有的主流
操作系統中，甚至可以運行在移動終端 ( 基於 ARM 的處理器，如 HTC G7 等 )。V8 最早被開發用以嵌入到 Google 的開源瀏覽器 Chrome 中，但是 V8 是一個可以獨立的模塊，完全可以嵌入您自己的應用，著名的 Node.js( 一個異步的服務器框架，可以在服務端使用 JavaScript 寫出高效的網絡服務器 ) 就是基於 V8 引擎的。
和其他 JavaScript 引擎一樣，V8 會編譯 / 執行 JavaScript 代碼，管理內存，負責垃圾回收，與宿主語言的交互等。V8 的垃圾回收器採用了衆多技術，使得其運行效率大大提高。通過暴露宿主對象 ( 變量，函數等 ) 到 JavaScript，JavaScript 可以訪問宿主環境中的對象，並在腳本中完成對宿主對象的操作。
V8 引擎基本概念
圖 1. V8 引擎基本概念關係圖 ( 根據 Google V8 官方文檔 )
handle
handle 是指向對象的指針，在 V8 中，所有的對象都通過 handle 來引用，handle 主要用於 V8 的垃圾回收機制。
在 V8 中，handle 分爲兩種：持久化 (Persistent)handle 和本地 (Local)handle，持久化 handle 存放在堆上，而本地 handle 存放在棧上。這個與 C/C++ 中的堆和棧的意義相同 ( 簡而言之，堆上的空間需要開發人員自己申請，使用完成之後顯式的釋放；而棧上的爲自動變量，在退出函數 / 方法之後自動被釋放 )。持久化 handle 與本地 handle 都是 Handle 的子類。在 V8 中，所有數據訪問均需要通過 handle。需要注意的是，使用持久化 handle 之後，需要顯式的調用 Dispose() 來通知垃圾回收機制。
作用域 (scope)
scope 是 handle 的集合，可以包含若干個 handle，這樣就無需將每個 handle 逐次釋放，而是直接釋放整個 scope。
在使用本地 handle 時，需要聲明一個 HandleScope 的實例，scope 是 handle 的容器，使用 scope，則無需依次釋放 handle。
HandleScope handle_scope; Local<ObjectTemplate> temp;
上下文 (context)
context 是一個執行器環境，使用 context 可以將相互分離的 JavaScript 腳本在同一個 V8 實例中運行，而互不干涉。在運行 JavaScript 腳本是，需要顯式的指定 context 對象。
數據及模板
由於 C++ 原生數據類型與 JavaScript 中數據類型有很大差異，因此 V8 提供了 Data 類，從 JavaScript 到 C++，從 C++ 到 JavaScrpt 都會用到這個類及其子類，比如：
Handle<Value> Add(const Arguments& args){
int a = args[0]->Uint32Value();
int b = args[1]->Uint32Value();
return Integer::New(a+b);
}
Integer 即爲 Data 的一個子類。
V8 中，有兩個模板 (Template) 類 ( 並非 C++ 中的模板類 )：對象模板 (ObjectTempalte) 和函數模板 (FunctionTemplate)，這兩個模板類用以定義 JavaScript 對象和 JavaScript 函數。我們在後續的小節部分將會接觸到模板類的實例。通過使用 ObjectTemplate，可以將 C++ 中的對象暴露給腳本環境，類似的，FunctionTemplate 用以將 C++ 函數暴露給腳本環境，以供腳本使用。
初始化 context 是使用 V8 引擎所必需的過程，代碼非常簡單：
Persistent<Context> context = Context::New();
V8 引擎使用示例
有了上面所述的基本概念之後，我們來看一下一個使用 V8 引擎的應用程序的基本流程：
- 創建 HandleScope 實例
- 創建一個持久化的 Context
- 進入 Context
- 創建腳本字符串
- 創建 Script 對象，通過 Script::Compile()
- 執行腳本對象的 Run 方法
- 獲取 / 處理結果
- 顯式的調用 Context 的 Dispose 方法
基本代碼模板
清單 1. 代碼模塊
#include <v8.h>
using namespace v8;
int main(int argc, char *argv[]) {
// 創建一個句柄作用域 ( 在棧上 )
HandleScope handle_scope;
// 創建一個新的上下文對象
Persistent<Context> context = Context::New();
// 進入上一步創建的上下文，用於編譯執行 helloworld
Context::Scope context_scope(context);
// 創建一個字符串對象，值爲'Hello, Wrold!', 字符串對象被 JS 引擎
// 求值後，結果爲'Hello, World!'
Handle<String> source = String::New("'Hello' + ', World!'");
// 編譯字符串對象爲腳本對象
Handle<Script> script = Script::Compile(source);
// 執行腳本，獲取結果
Handle <Value> result = script->Run();
// 釋放上下文資源
context.Dispose();
// 轉換結果爲字符串
String::AsciiValue ascii(result);
printf("%s\n", *ascii);
return 0;
}
以上代碼爲一個使用 V8 引擎來運行腳本的基本模板，可以看到，開發人員可以很容易的在自己的代碼中嵌入 V8 來處理 JavaScript 腳本。我們在下面小節中詳細討論如何在腳本中訪問 C++ 資源。
使用 C++ 變量
在 JavaScript 與 V8 間共享變量事實上是非常容易的，基本模板如下：
清單 2. 共享變量
static type xxx;
static Handle<Value> xxxGetter(
Local<String> name,
const AccessorInfo& info){
//code about get xxx
}
static void xxxSetter(
Local<String> name,
Local<Value> value,
const AccessorInfo& info){
//code about set xxx
}
首先在 C++ 中定義數據，並以約定的方式定義 getter/setter 函數，然後需要將 getter/setter 通過下列機制公開給腳本：
global->SetAccessor(String::New("xxx"), xxxGetter, xxxSetter);
其中，global 對象爲一個全局對象的模板：
Handle<ObjectTemplate> global = ObjectTemplate::New();
下面我們來看一個實例：
清單 3. 實例 1
static char sname[512] = {0};
static Handle<Value> NameGetter(Local<String> name,
const AccessorInfo& info) {
return String::New((char*)&sname,strlen((char*)&sname));
}
static void NameSetter(Local<String> name,
Local<Value> value,
const AccessorInfo& info) {
Local<String> str = value->ToString();
str->WriteAscii((char*)&sname);
}
定義了 NameGetter, NameSetter 之後，在 main 函數中，將其註冊在 global 上：
// Create a template for the global object.
Handle<ObjectTemplate> global = ObjectTemplate::New();
//public the name variable to script
global->SetAccessor(String::New("name"), NameGetter, NameSetter);
在 C++ 中，將 sname 的值設置爲”cpp”：
//set sname to "cpp" in cpp program
strncpy(sname, "cpp", sizeof(sname));
然後在 JavaScript 中訪問該變量，並修改：
print(name);
//set the variable `name` to "js"
name='js';
print(name);
運行結果如下：
cpp js
運行腳本，第一個 print 調用會打印在 C++ 代碼中設置的 name 變量的值：cpp，然後我們在腳本中修改 name 值爲：js，再次調用 print 函數則打印出設置後的值：js。
調用 C++ 函數
在 JavaScript 中調用 C++ 函數是腳本化最常見的方式，通過使用 C++ 函數，可以極大程度的增強 JavaScript 腳本的能力，如文件讀寫，網絡 / 數據庫訪問，圖形 / 圖像處理等等，而在 V8 中，調用 C++ 函數也非常的方便。
在 C++ 代碼中，定義以下原型的函數：
Handle<Value> function(constArguments& args){
//return something
}
然後，再將其公開給腳本：
global->Set(String::New("function"),FunctionTemplate::New(function));
同樣，我們來看兩個示例：
清單 4. 實例 2
Handle<Value> Add(const Arguments& args){
int a = args[0]->Uint32Value();
int b = args[1]->Uint32Value();
return Integer::New(a+b);
}
Handle<Value> Print(const Arguments& args) {
bool first = true;
for (int i = 0; i < args.Length(); i++) {
HandleScope handle_scope;
if (first) {
first = false;
} else {
printf(" ");
}
String::Utf8Value str(args[i]);
const char* cstr = ToCString(str);
printf("%s", cstr);
}
printf("\n");
fflush(stdout);
return Undefined();
}
函數 Add 將兩個參數相加，並返回和。函數 Print 接受任意多個參數，然後將參數轉換爲字符串輸出，最後輸出換行。
global->Set(String::New("print"), FunctionTemplate::New(Print));
global->Set(String::New("add"), FunctionTemplate::New(Add));
我們定義以下腳本：
var x = (function(a, b){
return a + b;
})(12, 7);
print(x);
//invoke function add defined in cpp
var y = add(43, 9);
print(y);
運行結果如下：
19 52
使用 C++ 類
如果從面向對象的視角來分析，最合理的方式是將 C++ 類公開給 JavaScript，這樣可以將 JavaScript 內置的對象數量大大增加，從而儘可能少的使用宿主語言，而更大的利用動態語言的靈活性和擴展性。事實上，C++ 語言概念衆多，內容繁複，學習曲線較 JavaScript 遠爲陡峭。最好的應用場景是：既有腳本語言的靈活性，又有 C/C++ 等系統語言的效率。使用 V8 引擎，可以很方便的將 C++ 類”包裝”成可供 JavaScript 使用的資源。
我們這裏舉一個較爲簡單的例子，定義一個 Person 類，然後將這個類包裝並暴露給 JavaScript 腳本，在腳本中新建 Person 類的對象，使用 Person 對象的方法。
首先，我們在 C++ 中定義好類 Person：
清單 5. 定義類
class Person {
private:
unsigned int age;
char name[512];
public:
Person(unsigned int age, char *name) {
this->age = age;
strncpy(this->name, name, sizeof(this->name));
}
unsigned int getAge() {
return this->age;
}
void setAge(unsigned int nage) {
this->age = nage;
}
char *getName() {
return this->name;
}
void setName(char *nname) {
strncpy(this->name, nname, sizeof(this->name));
}
};
Person 類的結構很簡單，只包含兩個字段 age 和 name，並定義了各自的 getter/setter. 然後我們來定義構造器的包裝：
Handle<Value> PersonConstructor(const Arguments& args){
Handle<Object> object = args.This();
HandleScope handle_scope;
int age = args[0]->Uint32Value();
String::Utf8Value str(args[1]);
char* name = ToCString(str);
Person *person = new Person(age, name);
object->SetInternalField(0, External::New(person));
return object;
}
從函數原型上可以看出，構造器的包裝與上一小節中，函數的包裝是一致的，因爲構造函數在 V8 看來，也是一個函數。需要注意的是，從 args 中獲取參數並轉換爲合適的類型之後，我們根據此參數來調用 Person 類實際的構造函數，並將其設置在 object 的內部字段中。緊接着，我們需要包裝 Person 類的 getter/setter：
Handle<Value> PersonGetAge(const Arguments& args){
Local<Object> self = args.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
void *ptr = wrap->Value();
return Integer::New(static_cast<Person*>(ptr)->getAge());
}
Handle<Value> PersonSetAge(const Arguments& args)
{
Local<Object> self = args.Holder();
Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
void* ptr = wrap->Value();
static_cast<Person*>(ptr)->setAge(args[0]->Uint32Value());
return Undefined();
}
而 getName 和 setName 的與上例類似。在對函數包裝完成之後，需要將 Person 類暴露給腳本環境：
首先，創建一個新的函數模板，將其與字符串”Person”綁定，並放入 global：
Handle<FunctionTemplate> person_template = FunctionTemplate::New(PersonConstructor);
person_template->SetClassName(String::New("Person"));
global->Set(String::New("Person"), person_template);
然後定義原型模板：
Handle<ObjectTemplate> person_proto = person_template->PrototypeTemplate();
person_proto->Set("getAge", FunctionTemplate::New(PersonGetAge));
person_proto->Set("setAge", FunctionTemplate::New(PersonSetAge));
person_proto->Set("getName", FunctionTemplate::New(PersonGetName));
person_proto->Set("setName", FunctionTemplate::New(PersonSetName));
最後設置實例模板：
Handle<ObjectTemplate> person_inst = person_template->InstanceTemplate(); person_inst->SetInternalFieldCount(1);
隨後，創建一個用以測試的腳本：
//global function to print out detail info of person
function printPerson(person){
print(person.getAge()+":"+person.getName());
}
//new a person object
var person = new Person(26, "juntao");
//print it out
printPerson(person);
//set new value
person.setAge(28);
person.setName("juntao.qiu");
//print it out
printPerson(person);
運行得到以下結果：
26:juntao 28:juntao.qiu
簡單示例
在這一小節中，我們將編寫一個簡單的桌面計算器：表達式求值部分通過 V8 引擎來進行，而流程控制部分則放在 C++ 代碼中，這樣可以將表達式解析等複雜細節繞開。同時，我們還得到了一個額外的好處，用戶在腳本中可以自定義函數，從而可以在計算器中定義自己的運算規則。
桌上計算器
計算器程序首先進入一個 MainLoop，從標準輸入讀取一行命令，然後調用 V8 引擎去求值，然後將結果打印到控制檯，然後再進入循環：
清單 6. 桌面計算器示例
void MainLoop(Handle<Context> context) {
while(true) {
char buffer[1024] = {0};
printf("$ ");
char *str = fgets(buffer, sizeof(buffer), stdin);
if(str == NULL) {
break;
}
HandleScope handle_scope;
ExecuteString(String::New(str), String::New("calc"), true);
}
}
在 main 函數中設置全局對象，創建上下文對象，並進入 MainLoop：
int main(int argc, char *argv[]){
HandleScope handle_scope;
// Create a template for the global object.
Handle<ObjectTemplate> global = ObjectTemplate::New();
// Expose the local functions to script
global->Set(String::New("load"), FunctionTemplate::New(Load));
global->Set(String::New("print"), FunctionTemplate::New(Print));
global->Set(String::New("quit"), FunctionTemplate::New(Quit));
// Create a new execution environment containing the built-in
// functions
Handle<Context> context = Context::New(NULL, global);
// Enter the newly created execution environment.
Context::Scope context_scope(context);
// Enter main loop
MainLoop(context);
V8::Dispose();
return 0;
}
在 main 函數中，爲腳本提供了三個函數，load 函數用以將用戶指定的腳本加載進來，並放入全局的上下文中一邊引用，print 函數用以打印結果，而 quit 提供用戶退出計算器的功能。
測試一下：
$ 1+2
3
$ (10+3)/(9.0-5)
3.25
$ typeof print
function
$ typeof non
undefined
// 自定義函數
$ function add(a, b){return a+b;}
$ add(999, 2323)
3322
// 查看 print 標識符的內容
$ print
function print() { [native code] }
load 函數提供了用戶自定義函數的功能，將腳本文件作爲一個字符串加載到內存，然後對該字符串編譯，求值，並將處理過的腳本對象放入當前 context 中，以便用戶使用。
Handle<Value> Load(const Arguments& args){
if(args.Length() != 1){
return Undefined();
}
HandleScope handle_scope;
String::Utf8Value file(args[0]);
Handle<String> source = ReadFile(*file);
ExecuteString(source, String::New(*file), false);
return Undefined();
}
而 ExecuteString 函數，負責將字符串編譯運行：
bool ExecuteString(Handle<String> source,
Handle<Value> name,
bool print_result)
{
HandleScope handle_scope;
TryCatch try_catch;
Handle<Script> script = Script::Compile(source, name);
if (script.IsEmpty()) {
return false;
} else {
Handle<Value> result = script->Run();
if (result.IsEmpty()) {
return false;
} else {
if (print_result && !result->IsUndefined()) {
String::Utf8Value str(result);
const char* cstr = ToCString(str);
printf("%s\n", cstr);
}
return true;
}
}
}
將下列內容存入一個文本文件，並命令爲 calc.js：
function sum(){
var s = 0;
for(var i = 0; i < arguments.length; i++){
s += arguments[i];
}
return s;
}
function avg(){
var args = arguments;
var count = args.length;
var sum = 0;
for(var i = 0; i < count; i++){
sum += args[i];
}
return sum/count;
}
然後在計算器中測試：
// 此時 sum 符號位定義
$ typeof sum
undefined
// 加載文件，並求值
$ load("calc.js")
// 可以看到，sum 的類型爲函數
$ typeof sum
function
$ sum(1,2,3,4,5,6,7,8,9)
45
結束語
使用 V8 引擎，可以輕鬆的將腳本的好處帶進 C++ 應用，使得 C++ 應用更具靈活性，擴展性。我們在文中討論了基本的模板，如何使用 C++ 變量，函數，以及類。最後的實例中給出了一個計算器的原型。由於 V8 的設計原則，開發人員可以快速的將其嵌入到自己的應用中，並且無需太過擔心腳本語言的執行效率。