Question

我试图将V8包装在一个类结构中，其中存在一个将JavaScript回调暴露给C ++代码的对象，它应该进行一些数据处理。

我们的想法是保持上下文和handle_scope对所有参与的类都可用，即我想到了一个“全局”状态。我把它归结为以下示例：

using namespace v8;

Persistent<Context> context;
HandleScope handle_scope;

struct CallBackTest {
HandleScope handle_scope;
Handle<v8::Function> function;
void RegisterCallback(Handle<v8::Function> f) {
    function = f;
}

bool MakeCall(int argc, Handle<Value> args[2]) {
    Handle<Value> js_result = function->Call(context->Global(), argc, args);
    String::AsciiValue ascii(js_result);
    return atoi(*ascii);
}
};

struct V8Wrapper {
CallBackTest tester;
V8Wrapper() {
    context = Context::New();
    Context::Scope context_scope(context);

    Handle<String> source;
    Handle<Script> script;
    Handle<Value> result;

    source = String::New("function test_function() { return (arguments[0] == arguments[1]); };");

    script = Script::Compile(source);

    result = script->Run();

    Handle<v8::Value> value1 = context->Global()->Get(String::New("test_function"));
    if(!value1->IsFunction()) {
        std::cout << "function not found" << std::endl;
    } else {
        Handle<v8::Function> func1 = v8::Handle<v8::Function>::Cast(value1);
        tester.RegisterCallback(func1);
    }
}
};

int main(int argc, char* argv[]) {
V8Wrapper wrap;
Handle<Value> args[2];
Handle<Value> js_result;
int final_result;

args[0] = v8::String::New("1");
args[1] = v8::String::New("1");

final_result = wrap.tester.MakeCall(2, args);

if(final_result == 1) {
    std::cout << "Matched\n";
} else {
    std::cout << "NOT Matched\n";
}
}

感谢。

Answer 1

我认为您的问题是对HandleScope的误解。手柄必须“居住”在已定义HandleScope的范围内。 HandleScope的概念不是全局结构的概念，它必须在某个全局位置定义，而是对应于类似堆栈的概念。

为什么V8在课堂上被包装时会崩溃

1 个答案: