Javascript 使用v8 shell中的stringify

我正在创建一个基于v8 shell的控制台，我使用了v8附带的示例代码，它运行得很好，但我试图将v8:：object转换为它的字符串版本（json），但没有找到一种方法

下面是我在shell.cc中的示例代码：

    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("");
    }

在shell中，我创建了一个文件test.js，其中包含以下内容：

    var a = {  name: 'John' };
    test(a);

在shell控制台中执行js后，我得到了这个结果：

    [object Object]
    It's an object

我想要的是：

    { "name": "John" }

如果我将js代码更改为：

    var a = { name: 'John'}
    test(JSON.stringify(a));

它工作得很好，但我不想让用户知道如何将javascript变量解析为json，我也不想检查对象上的每个输入并手动解析它

有没有办法在C中的shell.cc代码中执行相同的指令？比如：

    v8::Handle<v8::String> temp = JSON.parse(arg[0]);

v8:：Handle temp=JSON.parse（arg[0]）；

更新：这就是我处理这件事的方式，但我想要一个更干净的方法来做同样的事情：

    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("");
    }

const char*toJson（const v8:：Local和obj）{
std：：stringstream-ss；
ss GetPropertyNames（）；
对于（int x=0；xLength（）；x++）{
如果（x！=0）{
ss-Get（x））；
ss-GetInternalField（x）；
如果（val->IsObject（））{
ss-ToObject（））；
}否则{
ss我发现这种方法可以使用v8s内置的
JSON.parse
函数实现反向操作（JSON到v8对象）

将其调整为使用
JSON.stringify
会有点像这样（未经测试）：

handletojson（句柄对象）
{
手镜镜；
句柄上下文=上下文：：GetCurrent（）；
句柄全局=上下文->全局（）；
Handle JSON=global->Get（String:：New（“JSON”）->ToObject（）；
handlejson_stringify=Handle:：Cast（JSON->Get（String:：New（“stringify”））；
返回scope.Close（JSON_stringify->Call（JSON，1，object））；
}
我想避免在自己实现的
V8:：Value
-to-
string
转换中使用现在不推荐的V8方法，所以我从Michael的答案中汲取灵感，将此函数组合在一起。缺点是它非常冗长：

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;
}

bool MakeStringValue（const string&str，v8:：Isolate*Isolate，
v8:：句柄*输出值）{
常量v8:：Maybellocal可能\u string=v8:：string:：NewFromUtf8(
孤立，str.c_str（），v8:：NewStringType:：kNormal，str.size（）；
v8:：句柄值；
if（！maybe_string.ToLocal（&value））{
返回false；
}
*输出值=静态值；
返回true；
}
bool ConvertValueToString（v8:：句柄值，v8:：隔离*隔离，
v8:：本地上下文，
字符串*值（字符串）{
v8:：Local global=context->global（）；
v8:：处理json_字符串_值；
v8:：Handle stringify_string_value；
如果（！MakeStringValue（“JSON”，隔离，&JSON\u字符串\u值）||
！MakeStringValue（“字符串化、隔离和字符串化\u字符串\u值））{
返回false；
}
const v8:：MaybeLocal maybe_json_值=
全局->获取（上下文，json字符串值）；
v8:：处理json_值；
if（！maybe_json_value.ToLocal（&json_value））{
返回false；
}
v8:：MaybeLocal maybe_json_object=json_value->ToObject（上下文）；
处理json_对象；
if（！maybe_json_object.ToLocal（&json_object））{
返回false；
}
常量v8:：MaybeLocal可能会字符串化值=
json_object->Get（上下文、字符串化_字符串_值）；
v8:：句柄字符串化_值；
if（！maybe_stringify_value.ToLocal（&stringify_value））{
返回false；
}
v8:：Function*stringify_Function=v8:：Function:：Cast（*stringify_值）；
v8:：TryCatch try_catch（隔离）；
常量v8:：Maybellocal可能是结果=
stringify_函数->调用（上下文、json_对象、1和值）；
v8：局部结果；
如果（try_catch.hascapt（）||！可能_result.ToLocal（&result）||
result.IsEmpty（）| | result->IsNullOrUndefined（）| |！result->IsString（））{
返回false；
}
v8:：本地结果_字符串；
if（！result->ToString（上下文）.ToLocal（&result\u字符串））{
返回false；
}
v8:：String:：Utf8Value utf8\u值（结果\u字符串）；
//运算符*返回常量字符*。
如果（*utf8_值==nullptr）{
返回false；
}
value\u string->assign（*utf8\u value，utf8\u value.length（））；
返回true；
}
如果您使用的是较新的V8（如8.3），代码如下：

void静态jsonStringify（v8:：本地上下文，v8:：本地值）{
自动隔离=上下文->获取隔离（）；
自动全局=上下文->全局（）；
auto json=global->Get（context，v8:：String:：NewFromUtf8（隔离，“json”，v8:：NewStringType:：kNormal）.ToLocalChecked（））.ToLocalChecked（）.As（）；
auto stringify=json->Get（上下文，v8:：String:：NewFromUtf8（隔离，“stringify”，v8:：NewStringType:：kNormal）.ToLocalChecked（））.ToLocalChecked（）.As（）；
auto v=stringify->Call（上下文、未定义（隔离）、1和值）；
v8:：String:：Utf8Value json_值（隔离，v）；
标准：：cout
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;
}