¿Cómo accedo y llamo a las propiedades y métodos del objeto Javascript desde C++ usando V8?

Question

Me gustaría un ejemplo de cómo acceder y llamar a las propiedades y métodos de objetos JavaScript desde C++ utilizando el motor v8. La documentación muestra cómo acceder a los objetos y funciones de C++ a través de JavaScript, pero no al revés.

Esto es un simple constructor de objetos y la instancia en JS:

function MyObj() 
{ 
    this.myArray = []; 
    this.myDouble = 0; 
    this.myFunction = function(arg1,arg2) 
     { return (myDouble + arg1 + arg2); } 
} 

var globalObject = new myObj(); 

¿Cómo puedo acceder a propiedades y métodos de GlobalObject? También una pregunta algo relacionada: ¿cómo puedo poblar la matriz (globalObject.myArray) desde C++?

Regards,

Pris

Answer 1

no han probado los ejemplos a continuación.

Pero creo que da un ejemplo de lo que quiere.

#include <v8.h> 
using namespace v8; 
int main(int argc, char* argv[]) { 
    // Create a handle scope 
    HandleScope handle_scope; 
    // Create a new context. 
    Handle<Context> context = Context::New(); 
    // Enter the created context for compiling and 
    // running the script. 
    Context::Scope context_scope(context); 
    // Create a new script 
    const char* script = "function MyObj() { this.myArray = []; this.myDouble = 0; this.myFunction = function(arg1,arg2) { return (myDouble + arg1 + arg2); } } var globalObject = new myObj();" 
    // Create a string containing the JavaScript source code. 
    Handle<String> source = String::New("script); 
    // Compile the source code. 
    Handle<Script> script = Script::Compile(source); 
    // Running the script 
    // Run the script to get the result. 
    Handle<Value> scriptresult = script->Run(); 
    // Convert the result to an ASCII string and print it. 
    String::AsciiValue ascii(scriptresult); 
    printf("%s\n", *ascii); 

    // Get the object 
    Handle<Object> object = Local::Cast(context->Global()->Get(String::New("globalObject"))); 
    // Get the Properties 
    Handle<Value> arrayproperty = Handle::Cast(object->Get(String::New("myArray"))); 
    Handle<Value> doubleproperty = Handle::Cast(object->Get(String::New("myDouble"))); 
    String::AsciiValue ascii2(arrayproperty); 
    String::AsciiValue ascii3(doubleproperty); 
    printf("%s\n", *ascii2); 
    printf("%s\n", *ascii3); 
    // Call the function 
    Handle fun_to_call = Handle::Cast(object->Get(String::New("myFunction"))); 
    int argcount = 0; 
    Handle argarray[] = NULL; 

    Handle functionresult = fun_to_call->Call(object, argcount, argarray); 
// argcount and argarray are your standard arguments to a function 

    return 0; 


} 

En cuanto a la forma de modificar la matriz creo que estaría utilizando

// Get the object 
Handle<Object> object = Local::Cast(context->Global()->Get(String::New("globalObject")))1; 

//Initialise array 
int num[4] = {1,2,3,4}; 
v8::Local<v8::Array> arguments = v8::Array::New(num); 
for (int i = 0; i < args; i++) { 
    arguments.Set(v8::Number::New(i), v8::String::New(args[i])); 
} 

// Set Array 
object->Set(v8::String::New("myArray"), arguments); 

Referencias

CodeProject Using V8

Connecting C++ to Javascript bungeeconnect

Google V8 Shell Sample Code

Google V8 Header File

V8 Users Mailing List Can you populate a v8::Array from C++? Thread

Answer 2

Como seguimiento a la respuesta exhaustiva de Appleman, por lo que vale la pena, tuve que usar -> en lugar de ., y usted no tiene que asignar un nuevo v8::Number para el primer argumento a Set:

v8::Local<v8::Array> r = v8::Array::New(10); 
for (uint32_t i = 0; i < 10; ++i) { 
    r->Set(i, v8::Number::New(i)); 
} 

Answer 3

lo siento por refresco, pero yo estaba buscando exactamente lo mismo y yo dont't así que tal vez alguien tendrá eso.

targetObj->GetOwnPropertyNames(context,v8::PropertyFilter::ALL_PROPERTIES) 

Sólo tiene que añadir un filtro :))