基于libv8 3.14 C++绑定的脚本应用序列化问题咨询

嘿，我之前在处理libv8 3.x版本的C绑定序列化时，正好遇到过和你一模一样的问题——用内置的JSON.stringify()处理带C包装对象的JS结构时，这些原生对象总会被序列化成空对象{}，完全达不到预期。给你几个经过验证的解决方案，适配3.14版本的特性：

方案1：给包装对象添加toJSON方法 #

JSON.stringify有个内置特性：遇到对象时会自动调用它的toJSON()方法，用返回值作为序列化的内容。你只需要在每个C++包装类的ObjectTemplate里添加这个方法，把原生对象的关键数据转换成可序列化的JS对象即可。

示例代码：

// 假设你的C++原生类是NativeClass，以下是构建其ObjectTemplate的逻辑
v8::Handle<v8::ObjectTemplate> CreateNativeClassTemplate(v8::Isolate* isolate) {
    auto tpl = v8::ObjectTemplate::New(isolate);
    // 设置内部字段，用来存储NativeClass的指针（这里索引0存指针）
    tpl->SetInternalFieldCount(1);
    
    // 给包装对象添加toJSON方法
    tpl->Set(
        v8::String::NewFromUtf8(isolate, "toJSON"),
        v8::FunctionTemplate::New(isolate, NativeClassToJSON)
    );
    
    // 其他暴露给JS的方法/属性...
    return tpl;
}

// toJSON方法的C++实现
void NativeClassToJSON(const v8::FunctionCallbackInfo<v8::Value>& args) {
    v8::Isolate* isolate = args.GetIsolate();
    // 获取当前包装对象，提取内部存储的NativeClass指针
    auto wrapped_obj = args.Holder();
    auto native_ptr = static_cast<NativeClass*>(
        wrapped_obj->GetInternalField(0).As<v8::External>()->Value()
    );
    
    // 创建一个普通JS对象，存入需要序列化的原生数据
    auto serializable_obj = v8::Object::New(isolate);
    serializable_obj->Set(
        v8::String::NewFromUtf8(isolate, "id"),
        v8::Number::New(isolate, native_ptr->GetId())
    );
    serializable_obj->Set(
        v8::String::NewFromUtf8(isolate, "data"),
        v8::String::NewFromUtf8(isolate, native_ptr->GetData().c_str())
    );
    // 按需添加其他需要序列化的属性...
    
    args.GetReturnValue().Set(serializable_obj);
}

这样当你调用JSON.stringify(to_store)时，遇到包装对象就会自动调用toJSON，把原生数据转换成可序列化的结构，而不是输出空对象。

方案2：在C++层实现自定义序列化函数 #

如果不想给每个包装类都加toJSON，或者需要更复杂的序列化逻辑（比如统一处理所有原生对象），可以在C++里写一个递归的序列化函数，手动遍历JS对象，遇到包装对象时直接提取原生数据。

核心思路是：

• 递归处理JS的基本类型、数组、普通对象
• 对C++包装对象，通过检查内部字段数量快速识别，然后提取数据生成JSON片段

示例代码片段：

v8::Handle<v8::String> SerializeJSValue(v8::Isolate* isolate, v8::Handle<v8::Value> value) {
    // 处理基本类型
    if (value->IsNumber()) {
        return v8::Number::Cast(*value)->ToString();
    } else if (value->IsString()) {
        // 注意：需要处理字符串中的引号转义，这里简化处理
        auto str = v8::String::Cast(*value);
        std::string escaped = "\"" + std::string(*v8::String::Utf8Value(isolate, str)) + "\"";
        return v8::String::NewFromUtf8(isolate, escaped.c_str());
    } else if (value->IsBoolean()) {
        return v8::Boolean::Cast(*value)->ToString();
    } else if (value->IsNull()) {
        return v8::String::NewFromUtf8(isolate, "null");
    }
    // 处理数组
    else if (value->IsArray()) {
        auto arr = v8::Array::Cast(*value);
        std::string json = "[";
        for (uint32_t i = 0; i < arr->Length(); ++i) {
            if (i > 0) json += ",";
            auto elem_str = SerializeJSValue(isolate, arr->Get(i));
            json += *v8::String::Utf8Value(isolate, elem_str);
        }
        json += "]";
        return v8::String::NewFromUtf8(isolate, json.c_str());
    }
    // 处理对象（包括C++包装对象）
    else if (value->IsObject()) {
        auto obj = v8::Object::Cast(*value);
        // 通过内部字段数量判断是否是C++包装对象
        if (obj->InternalFieldCount() > 0) {
            // 提取NativeClass指针，生成JSON片段
            auto native_ptr = static_cast<NativeClass*>(
                obj->GetInternalField(0).As<v8::External>()->Value()
            );
            std::string json = "{\"id\":" + std::to_string(native_ptr->GetId()) + 
                               ",\"data\":\"" + native_ptr->GetData() + "\"}";
            return v8::String::NewFromUtf8(isolate, json.c_str());
        } else {
            // 普通JS对象，遍历所有属性
            std::string json = "{";
            auto props = obj->GetPropertyNames();
            for (uint32_t i = 0; i < props->Length(); ++i) {
                if (i > 0) json += ",";
                auto prop_name = props->Get(i).As<v8::String>();
                auto prop_value = obj->Get(prop_name);
                auto name_str = *v8::String::Utf8Value(isolate, prop_name);
                auto value_str = *v8::String::Utf8Value(isolate, SerializeJSValue(isolate, prop_value));
                json += "\"" + std::string(name_str) + "\":" + value_str;
            }
            json += "}";
            return v8::String::NewFromUtf8(isolate, json.c_str());
        }
    }
    // 未知类型默认返回null
    return v8::String::NewFromUtf8(isolate, "null");
}

使用时，直接传入你要序列化的JS对象，就能得到完整的JSON字符串，不需要依赖JS层的JSON.stringify。

方案3：在JS层预处理对象 #

如果你更习惯在JS侧写逻辑，可以写一个工具函数，遍历待序列化的对象，把所有C++包装对象转换成普通JS对象，再调用JSON.stringify。

示例JS代码：

function prepareForSerialization(obj) {
    if (typeof obj === 'object' && obj !== null) {
        // 如果已经给包装对象加了toJSON，直接复用
        if (typeof obj.toJSON === 'function') {
            return obj.toJSON();
        }
        // 通过自定义标识判断是否是C++包装对象（比如你暴露的__nativeType__属性）
        if (obj.__nativeType__) {
            return {
                id: obj.getId(),
                data: obj.getData()
                // 按需添加其他属性
            };
        }
        // 处理数组
        if (Array.isArray(obj)) {
            return obj.map(item => prepareForSerialization(item));
        }
        // 处理普通对象
        const result = {};
        for (const key in obj) {
            if (obj.hasOwnProperty(key)) {
                result[key] = prepareForSerialization(obj[key]);
            }
        }
        return result;
    }
    // 基本类型直接返回
    return obj;
}

// 使用示例
const n = getWrappedNativeObject();
const to_store = { "a": 1, "b": n };
const serialized = JSON.stringify(prepareForSerialization(to_store));

然后在C++里调用这个JS函数，提取返回的字符串即可。

针对libv8 3.14的注意事项 #

• 3.14版本的Isolate API和新版本差异较大，比如v8::String::NewFromUtf8在新版本有更新，但这个版本可以直接用，注意编码问题。
• 访问内部字段时，一定要确保转换成v8::External再取指针，否则会导致崩溃。
• 如果你的包装类有继承关系，要确保每个子类的ObjectTemplate都正确设置了toJSON或者能被自定义序列化函数识别。

内容的提问来源于stack exchange，提问作者negativezero