todas - Llamar a una función javascript v8 desde c++ con un argumento

funciones que retornan valores en c++

Question

Estoy trabajando con c ++ y v8, y me he encontrado con el siguiente desafío: quiero poder definir una función en javascript usando v8, luego llamar a la función más adelante a través de c ++. Además, quiero poder pasar un argumento a la función javascript de c ++. Creo que el siguiente código fuente de ejemplo lo explicaría mejor. Verifique hacia el final del código de muestra para ver qué estoy tratando de lograr.

#include <v8.h>
#include <iostream>
#include <string>
#include <array>
using namespace v8;
int main(int argc, char* argv[]) {
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Create a new context.
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Handle<String> source;
Handle<Script> script;
Handle<Value> result;
// Create a string containing the JavaScript source code.
source = String::New("function test_function(test_arg) { var match = 0;if(test_arg[0] == test_arg[1]) { match = 1; }");
// Compile the source code.
script = Script::Compile(source);
// What I want to be able to do (this part isn''t valid code..
// it just represents what I would like to do.
// An array is defined in c++ called pass_arg,
// then passed to the javascript function test_function() as an argument
std::array< std::string, 2 > pass_arg = {"value1", "value2"};
int result = script->callFunction("test_function", pass_arg);
}

¿Algun consejo?

ACTUALIZAR:

Basándome en los consejos dados, he podido reunir el siguiente código. Ha sido probado y funciona:

#include <v8.h>
#include <iostream>
#include <string>
using namespace v8;
int main(int argc, char* argv[]) {
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Create a new context.
Persistent<Context> context = Context::New();
//context->AllowCodeGenerationFromStrings(true);
// Enter the created context for compiling and
// running the hello world script.
Context::Scope context_scope(context);
Handle<String> source;
Handle<Script> script;
Handle<Value> result;
// Create a string containing the JavaScript source code.
source = String::New("function test_function() { var match = 0;if(arguments[0] == arguments[1]) { match = 1; } return match; }");
// Compile the source code.
script = Script::Compile(source);
// Run the script to get the result.
result = script->Run();
// Dispose the persistent context.
context.Dispose();
// Convert the result to an ASCII string and print it.
//String::AsciiValue ascii(result);
//printf("%s/n", *ascii);
Handle<v8::Object> global = context->Global();
Handle<v8::Value> value = global->Get(String::New("test_function"));
Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
Handle<Value> args[2];
Handle<Value> js_result;
int final_result;
args[0] = v8::String::New("1");
args[1] = v8::String::New("1");
js_result = func->Call(global, 2, args);
String::AsciiValue ascii(js_result);
final_result = atoi(*ascii);
if(final_result == 1) {
std::cout << "Matched/n";
} else {
std::cout << "NOT Matched/n";
}
return 0;
}

Answer 1

No he probado esto, pero es posible que algo como esto funcione:

// ...define and compile "test_function"
Handle<v8::Object> global = context->Global();
Handle<v8::Value> value = global->Get(String::New("test_function"));
if (value->IsFunction()) {
Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
Handle<Value> args[2];
args[0] = v8::String::New("value1");
args[1] = v8::String::New("value2");
Handle<Value> js_result = func->Call(global, 2, args);
if (js_result->IsInt32()) {
int32_t result = js_result->ToInt32().Value();
// do something with the result
}
}

Editar:

Parece que su función javascript espera un solo argumento (que consiste en una matriz de dos valores), pero parece que estamos llamando a func al pasar dos argumentos.

Para probar esta hipótesis, puede cambiar su función javascript para tomar dos argumentos y compararlos, por ejemplo:

function test_function(test_arg1, test_arg2) {
var match = 0;
if (test_arg1 == test_arg2) {
match = 1;
} else {
match = 0;
}
return match;
}

Answer 2

Otro método más simple es el siguiente:

Handle<String> code = String::New(
"(function(arg) {/n/
console.log(arg);/n/
})");
Handle<Value> result = Script::Compile(code)->Run();
Handle<Function> function = Handle<Function>::Cast(result);
Local<Value> args[] = { String::New("testing!") };
func->Call(Context::GetCurrent()->Global(), 1, args);

Esencialmente, compile algo de código que devuelva una función anónima, luego llámelo con cualquier argumento que quiera pasar.