Javascript里有个C 系列文章：

Javascript里有个C：Part 1 – 基础

Javascript里有个C：Part 2 – 对象

Javascript里有个C：Part 3 - 深入对象

Javascript里有个C：Part 4 - 异步

Javascript里有个C：Part 5 - node.js

Javascript里有个C：Part 6 - 实战node.js Module

书至第三回。前两回当啷结束，C++里怎么摆弄Javascript，相信大家已略有所知。在本文，我们将更进一步。怎么从上帝视角玩弄Javascript？怎么把C++强力插入Javascript？这里都将一一解惑。

External

首先我们需要了解一种特殊的Value，v8::External，它的作用是把C++的对象包装成Javascript中的变量。External::New接受一个C++对象的指针作为初始化参数，然后返回一个包含这个指针的Handle对象供v8引擎使用。在使用这个Handle对象时可以通过External::Value函数来得到C++对象的指针，接口定义如下：

/**

 * A JavaScript value that wraps a C++ void*.  This type of value is

 * mainly used to associate C++ data structures with JavaScript

 * objects.

 *

 * The Wrap function V8 will return the most optimal Value object wrapping the

 * C++ void*. The type of the value is not guaranteed to be an External object

 * and no assumptions about its type should be made. To access the wrapped

 * value Unwrap should be used, all other operations on that object will lead

 * to unpredictable results.

 */

class External : public Value {

public:

  V8EXPORT static Local Wrap(void* data);

  static inline void* Unwrap(Handle obj);



  V8EXPORT static Local New(void* value);

  static inline External* Cast(Value* obj);

  V8EXPORT void* Value() const;

 private:

  V8EXPORT External();

  V8EXPORT static void CheckCast(v8::Value* obj);

  static inline void* QuickUnwrap(Handle obj);

  V8EXPORT static void* FullUnwrap(Handle obj);

};

需要注意的是，External::Wrap会尝试把指针作为数值进行处理，若不支持则等同于New。

和Handle不同，External并不会托管C++对象的生命期，所以你必须手动构造、释放用来包装的C++对象。比较常用的手段是，在C++的栈上建立对象，然后再用External进行托管。下面是一个例子[完整代码]：

    std::string str ("Hello World!");

    Local external = External::New (&str);

    cout << *static_cast (external->Value());

Template

怎么把Javascript的对象和C++的对象联系起来？v8::Object并未提供从C++对象构造的方法，而Javascript的函数v8::Function甚至没有提供初始化::New函数！这就需要一种特殊的类型，v8::Template。

Template是介于Javascript和C++变量间的中间层，你首先由C++对象生成一个Template，然后再由Template生成Javascript函数的对象。你可以事先在Template中准备好一些预备属性，然后生成的Javascript对象都将具备这些属性。

一个例子就是Google Chrome的DOM，DOM就是先用ObjectTemplate预先封装好对应的C++节点，最后再为每一个标签生成DOM对象。

FunctionTemplate

首先介绍FunctionTemplate，顾名思义，就是用来生成函数的Template。之前函数一直在文章里缺席，原因之一就是Javascript函数和C++函数的绑定必须仰赖Template。

FunctionTemplate的接口如下：

class V8EXPORT FunctionTemplate : public Template {

public:

  /** Creates a function template.*/

  static Local New(

      InvocationCallback callback = 0,

      Handle data = Handle(),

      Handle signature = Handle());

  /** Returns the unique function instance in the current execution context.*/

  Local GetFunction();



  /**

   * Set the call-handler callback for a FunctionTemplate.  This

   * callback is called whenever the function created from this

   * FunctionTemplate is called.

   */

  void SetCallHandler(InvocationCallback callback,

                      Handle data = Handle());

/** Causes the function template to inherit from a parent function template.*/

  void Inherit(Handle parent);



  /**

   * A PrototypeTemplate is the template used to create the prototype object

   * of the function created by this template.

   */

  Local PrototypeTemplate();



  /**

   * Set the class name of the FunctionTemplate.  This is used for

   * printing objects created with the function created from the

   * FunctionTemplate as its constructor.

   */

  void SetClassName(Handle name);

};

你可以使用FunctionTemplate::New ()生成一个空函数，然后用FunctionTemplate::SetCallHandler ()将其和C++函数绑定，或者直接靠FunctionTemplate::New (InvocationCallback callback)来用C++函数初始化一个FunctionTemplate。

用来生成FunctionTemplate的C++函数必须满足InvocationCallback的条件，即函数签名必须如下：

typedef Handle (*InvocationCallback)(const Arguments& args);

此后，你可以使用FunctionTemplate::GetFunction()来获取对应的v8::Function。但是一个FunctionTemplate只能生成一个Function，FunctionTemplate::GetFunction()返回的都是同一个实体。这是因为Javascript里显式声明的全局函数只有一个实例。

不过，得到生成的函数后，你可以使用Function::NewInstance返回一个函数对象，等同于Javascript中的var tmp = new func;。

下面是一个使用FunctionTemplate的简单例子[完整代码]:

Handle print (const Arguments& args) {

    HandleScope scope;



    for (int i = 0; i< args.Length(); ++i) {

        cout << *String::Utf8Value (args[i]) << " ";

    }   



    cout << endl;



    return Undefined ();

}



// main函数中



    // Generate Function

    Local func_tpl = FunctionTemplate::New (print);

    func_tpl->SetClassName (String::NewSymbol ("print"));

    Local func = func_tpl->GetFunction ();

    cout << *String::Utf8Value (func) << endl;



    // Generate parameters

    Local args[4] = {

        String::New ("I"),

        String::New ("Love"),

        String::New ("C++"),

        String::New ("!")

    };



    // Call Function

    func->Call (Object::New (), 4, args);

首先，我们定义了一个print函数，这个函数接受Arguments作为参数，Arguments实际上是一个包含了传进进来的参数的数组。接着我们建立了FunctionTemplate func_tpl，然后通过func_tpl->GetFunction得到函数实体，最后对这个函数实体进行调用。

那么，如果我们想要在Javascript代码中调用这个函数，应该怎么做呢，下面是一个演示[完整代码]：

    // Generate Function

    Local func_tpl = FunctionTemplate::New (print);

    context->Global()->Set (String::NewSymbol ("print"),

                            func_tpl->GetFunction ());



    // Call in javascript

    Local source = String::New ("print ('I', 'Love', 'C++', '!');");

    Script::Compile(source)->Run ();

修改之处主要是在全局作用域中加入我们的函数对象。

Function Instance

Javascript常用new Function ();的形式来创建对象，而C++中，Function::NewInstance可以返回一个函数的Instance。

比如下面的代码：

function girl (name) {

    this.name = name;

}



var alice = new girl ("Alice");

alice.age = 21;

对应到C++中则是[完整代码]：

Handle girl (const Arguments& args) {

    HandleScope scope;



    if (args.Length() != 1 && !args[0]->IsString ())

        return ThrowException(v8::String::New("Unexpected arguments"));



    args.This()->Set (String::New ("name"), args[0]);



    return Undefined ();

}



// 在main函数中

    Local func_tpl = FunctionTemplate::New (girl);



    Handle args[1] = { String::New ("Alice") };

    Handle