V8 Promise 'dann' wird nur aufgerufen, wenn sie im Konstruktor aufgelöst wird ⇐ C++

[Anonymous]

Ich habe das folgende Problem mit C ++/V8 Interoperabilität. Wenn ich das Versprechen außerhalb des Konstruktors auflöste, wird der dann Rückruf nie angerufen. Hier ist der JavaScript-V8-Code: < /p>

Code: Select all

'use strict';
v8log ("******** C++ Promise start ********");
const promiseFromCpp = new GetCppPromise();
v8log ("promise created");
promiseFromCpp.then(value => {
v8log ("C++::GetCppPromise()::Resolve->v8::then ", value);
}).catch(error => {
v8log (error);
});
v8log ("******* C++ Promise end   ********");
< /code>
Es gibt eine Konstruktorfunktion, die < /p>
 bereitgestellt wird.class cpp2v8
{
public:
static v8::Local resolver;
static void getNewPromise(const v8::FunctionCallbackInfo& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope handle_scope(isolate);
v8::Local context = isolate->GetCurrentContext();

resolver = v8::Promise::Resolver::New(context).ToLocalChecked();
v8::Local promise = resolver->GetPromise();

args.GetReturnValue().Set(promise);
}
};
v8::Local cpp2v8::resolver;

Und hier ist es so, wie es gelöst wird, siehe CPP2V8 :: Resolver-> Resolve am Ende genannt.

Code: Select all

    {
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope handle_scope(isolate);

v8::Local global = v8::ObjectTemplate::New(isolate);
v8api::registerLogToConsole(isolate, global);
//provide constructor function here
global->Set(v8::String::NewFromUtf8(isolate, "GetCppPromise").ToLocalChecked(), v8::FunctionTemplate::New(isolate, cpp2v8::getNewPromise));

v8::Local context = v8::Context::New(isolate, nullptr, global);
v8::Context::Scope context_scope(context);

context->Global();

// JavaScript code to create and use a Person object
const char* source = R"(
'use strict';
v8log ("******** C++ Promise start ********");
const promiseFromCpp = new GetCppPromise();
v8log ("promise created");
promiseFromCpp.then(value => {
v8log ("C++::GetCppPromise()::Resolve->v8::then ", value);
}).catch(error => {
v8log (error);
});
v8log ("******* C++ Promise end   ********");

)";

v8::Local source_str = v8::String::NewFromUtf8(isolate, source).ToLocalChecked();

v8::Local script = v8::Script::Compile(context, source_str).ToLocalChecked();
script->Run(context).ToLocalChecked();
cpp2v8::resolver->Resolve(context, v8::String::NewFromUtf8(isolate, "Promise resolved outside!").ToLocalChecked()).FromJust();
< /code>
Im obigen Code wird < /code> nie aufgerufen.class cpp2v8
{
public:
static void getNewPromise(const v8::FunctionCallbackInfo& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope handle_scope(isolate);
v8::Local context = isolate->GetCurrentContext();

v8::Local resolver = v8::Promise::Resolver::New(context).ToLocalChecked();
v8::Local promise = resolver->GetPromise();
//Resolve here, in constructor
resolver->Resolve(context, v8::String::NewFromUtf8(isolate, "Promise resolved in C++!").ToLocalChecked()).FromJust();

args.GetReturnValue().Set(promise);
}

Hier ist die Ausgabe, und es gibt sogar einen Eindruck von Asynchronität, wie dann aufgerufen wird, nachdem das Skript endet:
v8: ******** C++ Promise start ********
v8: promise created
v8: ******* C++ Promise end ********
v8: C++::GetCppPromise()::Resolve->v8::then Promise resolved in C++!
< /code>
Hier ist das Problem. Ich möchte das Versprechen nicht im Konstruktor lösen. Ich möchte es Anywhere im Code bei in jeder anderen Zeit beheben, das ist meiner Meinung nach genau das Gefühl eines Versprechens. Wie genau kann ich das machen?