如何确定JSON文件中含null值的多字典各字段的数据类型？

Python 实现 #

核心思路 #

• 采用流式解析避免一次性加载超大JSON文件占用过多内存；
• 遍历过程中记录每个字段的非null类型，一旦所有字段都确定类型，直接终止遍历，无需处理全部数据。

代码示例 #

首先安装流式JSON解析库：

pip install ijson

编写解析代码：

import ijson
from typing import Dict, Type

def detect_field_types(json_file_path: str) -> Dict[str, Type]:
    field_types = {}
    required_fields = None

    with open(json_file_path, 'rb') as f:
        # 流式读取每个JSON对象
        for item in ijson.items(f, 'item'):
            # 第一次遍历获取所有字段名
            if required_fields is None:
                required_fields = set(item.keys())
            
            for key, value in item.items():
                if value is not None and key not in field_types:
                    field_types[key] = type(value)
            
            # 所有字段类型都已确定，提前退出
            if required_fields and all(key in field_types for key in required_fields):
                break
    
    # 处理可能全为null的字段（可选）
    if required_fields:
        for key in required_fields - field_types.keys():
            field_types[key] = type(None)
    
    return field_types

# 调用示例
if __name__ == "__main__":
    types = detect_field_types("large_data.json")
    # 输出格式化结果
    type_strs = [str(t.__name__) for t in types.values()]
    print(f"<{', '.join(type_strs)}>")

C++ 实现 #

核心思路 #

• 使用SAX模式解析（如rapidjson），逐字符处理JSON数据，无需加载整个文档到内存；
• 维护一个字段类型映射表，遇到非null值时记录类型，所有字段类型确定后立即停止解析。

代码示例（基于rapidjson） #

引入rapidjson库后编写代码：

#include <iostream>
#include <fstream>
#include <unordered_map>
#include <typeindex>
#include <rapidjson/reader.h>
#include <rapidjson/filereadstream.h>

using namespace rapidjson;

class TypeDetectorHandler : public BaseReaderHandler<UTF8<>, TypeDetectorHandler> {
public:
    std::unordered_map<std::string, std::type_index> fieldTypes;
    std::string currentKey;
    std::unordered_set<std::string> allFields;
    bool hasAllTypes = false;

    bool Null() { return true; }
    bool Bool(bool) { return true; }
    bool Int(int) { recordType<int>(); return !hasAllTypes; }
    bool Uint(unsigned) { return true; }
    bool Int64(int64_t) { return true; }
    bool Uint64(uint64_t) { return true; }
    bool Double(double) { recordType<double>(); return !hasAllTypes; }
    bool String(const char* str, SizeType, bool) { recordType<std::string>(); return !hasAllTypes; }
    
    bool Key(const char* str, SizeType len, bool) {
        currentKey = std::string(str, len);
        if (allFields.empty()) {
            allFields.insert(currentKey);
        }
        return true;
    }

    bool StartObject() { return true; }
    bool EndObject(SizeType) {
        // 检查是否所有字段都已确定类型
        if (!allFields.empty()) {
            hasAllTypes = true;
            for (const auto& field : allFields) {
                if (fieldTypes.find(field) == fieldTypes.end()) {
                    hasAllTypes = false;
                    break;
                }
            }
        }
        return !hasAllTypes; // 返回false终止解析
    }

    bool StartArray() { return true; }
    bool EndArray(SizeType) { return true; }

private:
    template<typename T>
    void recordType() {
        if (fieldTypes.find(currentKey) == fieldTypes.end()) {
            fieldTypes[currentKey] = std::type_index(typeid(T));
        }
    }
};

int main() {
    FILE* fp = fopen("large_data.json", "r");
    char buffer[65536];
    FileReadStream is(fp, buffer, sizeof(buffer));

    TypeDetectorHandler handler;
    Reader reader;
    reader.Parse(is, handler);
    fclose(fp);

    // 输出格式化结果
    std::cout << "<";
    bool first = true;
    for (const auto& field : handler.allFields) {
        if (!first) std::cout << ", ";
        first = false;
        auto typeIt = handler.fieldTypes.find(field);
        if (typeIt != handler.fieldTypes.end()) {
            auto& typeIdx = typeIt->second;
            if (typeIdx == std::type_index(typeid(std::string))) {
                std::cout << "string";
            } else if (typeIdx == std::type_index(typeid(int))) {
                std::cout << "int";
            } else if (typeIdx == std::type_index(typeid(double))) {
                std::cout << "float";
            }
        } else {
            std::cout << "null";
        }
    }
    std::cout << ">" << std::endl;

    return 0;
}

关键优化点 #

• 提前终止遍历：只要每个字段都找到至少一个非null值，就停止处理剩余数据，大幅减少计算量；
• 流式解析：避免一次性加载超大JSON到内存，降低内存占用，适配10万+元素的数据集；
• 类型冲突处理：如果某个字段出现多种非null类型（如同时有int和float），可在代码中添加冲突检查逻辑（如抛出警告或选择更宽泛的类型）。

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