求高效方法：仅比较嵌套JSON对象的键与结构（忽略值）

我之前刚好处理过类似的需求——只对比嵌套JSON的键结构是否完全一致，完全不管值的内容。这里分享一个高效的通用实现思路，还有具体的代码示例，帮你快速解决问题~

核心思路 #

要实现只对比键和嵌套结构，核心是类型优先+递归遍历，明确几个关键判断逻辑：

• 类型不一致直接判定结构不同：比如一个是对象，另一个是数组/基本类型，直接返回不一致；
• 基本类型（字符串、数字、布尔、null）只要类型相同，不管值都算结构一致；
• 对象（字典）要先对比键集合是否完全匹配（数量+键名），再递归遍历每个键的子结构；
• 数组的处理看需求边界：如果像你示例里那样，只要两边都是数组类型就算结构一致（不管长度和元素值），直接返回true；如果需要数组元素的结构也一致（比如数组里的嵌套对象），就递归遍历每个元素的结构。

具体实现示例 #

下面给出两种常用语言的实现，默认按照你示例的逻辑（数组只要类型一致就算结构一致），如果需要校验数组元素结构，可以取消代码里的注释部分。

JavaScript 实现

function compareJsonKeysAndStructure(a, b) {
    // 单独处理null，因为typeof null返回'object'
    const isANull = a === null;
    const isBNull = b === null;
    if (isANull !== isBNull) return false;
    if (isANull && isBNull) return true;

    // 校验类型是否一致
    const typeA = typeof a;
    const typeB = typeof b;
    if (typeA !== typeB) return false;

    // 基本类型：只要类型相同就符合要求
    if (typeA !== 'object') return true;

    // 处理数组
    const isAArray = Array.isArray(a);
    const isBArray = Array.isArray(b);
    if (isAArray !== isBArray) return false;
    if (isAArray && isBArray) {
        // 若需要校验数组元素的结构，取消下面的注释
        /*
        for (let i = 0; i < Math.max(a.length, b.length); i++) {
            const itemA = a[i] ?? null;
            const itemB = b[i] ?? null;
            if (!compareJsonKeysAndStructure(itemA, itemB)) return false;
        }
        */
        return true;
    }

    // 处理对象（字典）
    const keysA = Object.keys(a);
    const keysB = Object.keys(b);
    if (keysA.length !== keysB.length) return false;

    // 校验所有键是否匹配，并递归检查子结构
    for (const key of keysA) {
        if (!keysB.includes(key)) return false;
        if (!compareJsonKeysAndStructure(a[key], b[key])) return false;
    }

    return true;
}

// 测试你的示例数据
const obj1 = { 
    name: 'my object', 
    description: 'it is an object', 
    details: { it: 'has', an: 'array', with: ['a', 'few', 'elements'] } 
};
const obj2 = { 
    name: 'updated object', 
    description: 'it is an object!', 
    details: { it: 'has', an: 'array', with: ['a', 'few', 'more', 'elements'] } 
};

console.log(compareJsonKeysAndStructure(obj1, obj2)); // 输出 true

Python 实现

def compare_json_keys_and_structure(a, b):
    # 处理None的特殊情况
    if a is None and b is None:
        return True
    if a is None or b is None:
        return False

    # 校验类型是否一致
    if type(a) != type(b):
        return False

    # 基本类型：只要类型相同就符合要求
    if not isinstance(a, (dict, list)):
        return True

    # 处理列表（数组）
    if isinstance(a, list):
        # 若需要校验数组元素的结构，取消下面的注释
        """
        # 遍历对应位置的元素
        for item_a, item_b in zip(a, b):
            if not compare_json_keys_and_structure(item_a, item_b):
                return False
        # 处理长度不同的剩余元素，这里默认剩余元素只要类型合法即可
        remaining_items = a[len(b):] if len(a) > len(b) else b[len(a):]
        for item in remaining_items:
            if not compare_json_keys_and_structure(item, None):
                return False
        """
        return True

    # 处理字典（对象）
    keys_a = set(a.keys())
    keys_b = set(b.keys())
    if keys_a != keys_b:
        return False

    # 递归检查每个键的子结构
    for key in keys_a:
        if not compare_json_keys_and_structure(a[key], b[key]):
            return False

    return True

# 测试你的示例数据
obj1 = { 
    'name': 'my object', 
    'description': 'it is an object', 
    'details': {'it': 'has', 'an': 'array', 'with': ['a', 'few', 'elements']} 
}
obj2 = { 
    'name': 'updated object', 
    'description': 'it is an object!', 
    'details': {'it': 'has', 'an': 'array', 'with': ['a', 'few', 'more', 'elements']} 
}

print(compare_json_keys_and_structure(obj1, obj2)) # 输出 True

优化建议 #

• 避免递归栈溢出：如果你的JSON嵌套极深（比如超过1000层），可以把递归改成迭代方式，用栈或队列来存储需要遍历的节点；
• 快速失败优化：比如先对比对象的键数量，数量不同直接返回false，不用后续递归；
• 特殊类型支持：如果需要处理Date、RegExp等特殊JSON类型，可以在类型判断环节添加对应的校验逻辑；

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