I'm creating a v8 shell based console, I took the sample code that cames with v8 and it's working very well, but I'm trying to convert a v8::object to the string version of it (json) but didnt findout a way to do it.
Here's my sample code inside the shell:
v8::Handle test(const v8::Arguments& args) {
v8::HandleScope handle_scope;
const char* json;
v8::String::Utf8Value strJson(args[0]);
printf(ToCString(json));
if (args[0]->IsObject()) {
printf("it's an object\n");
}
return v8::String::New("");
}
At the shell I created a file test.js with this:
var a = { name: 'John' };
test(a);
and I get this after executing the js within the shell console:
[object Object]
It's an object
What I want is:
{ "name": "John" }
if I change the js code to:
var a = { name: 'John'}
test(JSON.stringify(a));
it works very well, but I dont want the user having to know how to parse a javascript variable into json, and I dont want to check for every single input at the object and parse it manually.
Is there a way to execute the same instruction inside the shell code in C? something like:
v8::Handle<v8::String> temp = JSON.parse(arg[0]);
update: This is how I'm handling this, but I want a cleaner way to do the same:
const char* toJson(const v8::Local<v8::Object>& obj) {
std::stringstream ss;
ss << "{";
v8::Local<v8::Array> propertyNames = obj->GetPropertyNames();
for (int x = 0; x < propertyNames->Length(); x++) {
if (x != 0) {
ss << ", ";
}
v8::String::Utf8Value name(propertyNames->Get(x));
ss << "\"" << ToCString(name) << "\":";
v8::Local<v8::Value> val = obj->GetInternalField(x);
if (val->IsObject()) {
ss << toJson(val->ToObject());
} else {
ss << "\"" << ToCString(v8::String::Utf8Value(val)) << "\"";
}
}
ss << "}";
const char* result = ss.str().c_str();
return result;
}
v8::Handle test(const v8::Arguments& args) {
v8::HandleScope handle_scope;
const char* json;
v8::String::Utf8Value strJson(args[0]);
if (args[0]->IsObject()) {
char* json = toJson(args[0]);
// ...
// Some operations with the json
// ...
}
return v8::String::New("");
}
I'm creating a v8 shell based console, I took the sample code that cames with v8 and it's working very well, but I'm trying to convert a v8::object to the string version of it (json) but didnt findout a way to do it.
Here's my sample code inside the shell:
v8::Handle test(const v8::Arguments& args) {
v8::HandleScope handle_scope;
const char* json;
v8::String::Utf8Value strJson(args[0]);
printf(ToCString(json));
if (args[0]->IsObject()) {
printf("it's an object\n");
}
return v8::String::New("");
}
At the shell I created a file test.js with this:
var a = { name: 'John' };
test(a);
and I get this after executing the js within the shell console:
[object Object]
It's an object
What I want is:
{ "name": "John" }
if I change the js code to:
var a = { name: 'John'}
test(JSON.stringify(a));
it works very well, but I dont want the user having to know how to parse a javascript variable into json, and I dont want to check for every single input at the object and parse it manually.
Is there a way to execute the same instruction inside the shell code in C? something like:
v8::Handle<v8::String> temp = JSON.parse(arg[0]);
update: This is how I'm handling this, but I want a cleaner way to do the same:
const char* toJson(const v8::Local<v8::Object>& obj) {
std::stringstream ss;
ss << "{";
v8::Local<v8::Array> propertyNames = obj->GetPropertyNames();
for (int x = 0; x < propertyNames->Length(); x++) {
if (x != 0) {
ss << ", ";
}
v8::String::Utf8Value name(propertyNames->Get(x));
ss << "\"" << ToCString(name) << "\":";
v8::Local<v8::Value> val = obj->GetInternalField(x);
if (val->IsObject()) {
ss << toJson(val->ToObject());
} else {
ss << "\"" << ToCString(v8::String::Utf8Value(val)) << "\"";
}
}
ss << "}";
const char* result = ss.str().c_str();
return result;
}
v8::Handle test(const v8::Arguments& args) {
v8::HandleScope handle_scope;
const char* json;
v8::String::Utf8Value strJson(args[0]);
if (args[0]->IsObject()) {
char* json = toJson(args[0]);
// ...
// Some operations with the json
// ...
}
return v8::String::New("");
}
3 Answers
Reset to default 10I found this way of doing the reverse (JSON to v8 object), using v8s built in JSON.parse function. http://www.mail-archive./[email protected]/msg04430.html
Adjusting this to use JSON.stringify instead would look kind of like this (untested):
Handle<String> toJson(Handle<Value> object)
{
HandleScope scope;
Handle<Context> context = Context::GetCurrent();
Handle<Object> global = context->Global();
Handle<Object> JSON = global->Get(String::New("JSON"))->ToObject();
Handle<Function> JSON_stringify = Handle<Function>::Cast(JSON->Get(String::New("stringify")));
return scope.Close(JSON_stringify->Call(JSON, 1, object));
}
I wanted to avoid using now-deprecated V8 methods for my own implementation of v8::Value-to-string conversion, so I put together this function, taking inspiration from Michael's answer. The downside is that it's very verbose:
bool MakeStringValue(const string& str, v8::Isolate* isolate,
v8::Handle<v8::Value>* out_value) {
const v8::MaybeLocal<v8::String> maybe_string = v8::String::NewFromUtf8(
isolate, str.c_str(), v8::NewStringType::kNormal, str.size());
v8::Handle<v8::String> value;
if (!maybe_string.ToLocal(&value)) {
return false;
}
*out_value = static_cast<v8::Handle<v8::Value>>(value);
return true;
}
bool ConvertValueToString(v8::Handle<v8::Value> value, v8::Isolate* isolate,
v8::Local<v8::Context> context,
string* value_string) {
v8::Local<v8::Object> global = context->Global();
v8::Handle<v8::Value> json_string_value;
v8::Handle<v8::Value> stringify_string_value;
if (!MakeStringValue("JSON", isolate, &json_string_value) ||
!MakeStringValue("stringify", isolate, &stringify_string_value)) {
return false;
}
const v8::MaybeLocal<v8::Value> maybe_json_value =
global->Get(context, json_string_value);
v8::Handle<v8::Value> json_value;
if (!maybe_json_value.ToLocal(&json_value)) {
return false;
}
v8::MaybeLocal<v8::Object> maybe_json_object = json_value->ToObject(context);
v8::Handle<v8::Object> json_object;
if (!maybe_json_object.ToLocal(&json_object)) {
return false;
}
const v8::MaybeLocal<v8::Value> maybe_stringify_value =
json_object->Get(context, stringify_string_value);
v8::Handle<v8::Value> stringify_value;
if (!maybe_stringify_value.ToLocal(&stringify_value)) {
return false;
}
v8::Function* stringify_function = v8::Function::Cast(*stringify_value);
v8::TryCatch try_catch(isolate);
const v8::MaybeLocal<v8::Value> maybe_result =
stringify_function->Call(context, json_object, 1, &value);
v8::Local<v8::Value> result;
if (try_catch.HasCaught() || !maybe_result.ToLocal(&result) ||
result.IsEmpty() || result->IsNullOrUndefined() || !result->IsString()) {
return false;
}
v8::Local<v8::String> result_string;
if (!result->ToString(context).ToLocal(&result_string)) {
return false;
}
v8::String::Utf8Value utf8_value(result_string);
// operator* returns a const char*.
if (*utf8_value == nullptr) {
return false;
}
value_string->assign(*utf8_value, utf8_value.length());
return true;
}
If you are using newer V8(like 8.3), code is like this:
void static jsonStringify(v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
auto isolate = context->GetIsolate();
auto global = context->Global();
auto json = global->Get(context, v8::String::NewFromUtf8(isolate, "JSON", v8::NewStringType::kNormal).ToLocalChecked()).ToLocalChecked().As<v8::Object>();
auto stringify = json->Get(context, v8::String::NewFromUtf8(isolate, "stringify", v8::NewStringType::kNormal).ToLocalChecked()).ToLocalChecked().As<v8::Function>();
auto v = stringify->Call(context, Undefined(isolate), 1, &value).ToLocalChecked();
v8::String::Utf8Value json_value(isolate, v);
std::cout << "your json value" << &json_value;
}