如何判断json结构是否相同

如何判断JSON结构是否相同：实用方法与代码示例

在数据处理、接口测试或数据迁移等场景中，经常需要比较两个JSON对象的“结构”是否相同，而无需关心其具体值，JSON结构指的是字段的名称、数据类型（对象、数组、字符串、数字等）以及嵌套关系的相似性，本文将介绍几种判断JSON结构是否相同的方法，并提供相应的代码示例。

什么是JSON结构的“相同”？

在讨论判断方法前,首先需要明确“结构相同”的定义，两个JSON结构被认为相同，需满足以下条件：

1. 根类型相同：如果都是对象，或都是数组，或都是基本类型（字符串、数字、布尔值、null）。
2. 字段名相同（针对对象）：两个对象拥有相同名称的字段（顺序可以不同）。
3. 字段数量相同（针对对象）：字段的个数一致。
4. 嵌套结构相同：对于每个字段，其对应的值的结构也需满足上述条件（递归判断）。
   • 如果字段的值是对象,则这两个嵌套对象的结构需相同。
   • 如果字段的值是数组,则数组元素的类型需相同，并且如果数组元素是对象/数组，则其结构也需相同（通常判断数组所有元素的结构是否一致，或对应位置元素结构是否一致，取决于需求）。

注意：基本类型（字符串、数字、布尔、null）的结构就是其类型本身。"hello"和"world"的结构相同（都是字符串），123和456的结构相同（都是数字），但"hello"和123的结构不同。

判断JSON结构相同的常用方法

递归遍历比较（通用性强）

这是最直观的方法,通过递归遍历两个JSON对象，逐层比较它们的类型和结构。

思路：

1. 比较当前节点的类型,不同则结构不同。
2. 如果是对象：
   • 比较字段数量,不同则结构不同。
   • 遍历一个对象的每个字段,检查另一个对象是否也有同名字段，且对应字段值的结构相同（递归）。
3. 如果是数组：
   • 比较数组长度,不同则结构不同（如果要求对应位置元素结构相同）。
   • 遍历数组元素,比较每个元素的结构是否相同（递归），如果数组元素是对象/数组，则需递归判断其结构。
4. 如果是基本类型,类型相同则结构相同。

Python示例代码：

import json
def is_json_structure_same(json1, json2):
    # 类型不同，结构不同
    if type(json1) != type(json2):
        return False
    # 都是字典（对象）
    if isinstance(json1, dict) and isinstance(json2, dict):
        # 字段数量不同
        if len(json1) != len(json2):
            return False
        # 遍历json1的所有字段
        for key in json1:
            # json2没有该字段，或对应字段结构不同
            if key not in json2 or not is_json_structure_same(json1[key], json2[key]):
                return False
        return True
    # 都是列表（数组）
    elif isinstance(json1, list) and isinstance(json2, list):
        # 数组长度不同
        if len(json1) != len(json2):
            return False
        # 逐个元素比较结构
        for item1, item2 in zip(json1, json2):
            if not is_json_structure_same(item1, item2):
                return False
        return True
    # 都是基本类型，或都是None
    else:
        # 对于基本类型，只要类型相同就认为结构相同
        # 如果需要区分不同数字/字符串的结构，可以在这里添加更严格的判断
        return True
# 示例用法
json_str1 = '''
{
    "name": "Alice",
    "age": 30,
    "isStudent": false,
    "courses": ["Math", "Science"],
    "address": {
        "street": "123 Main St",
        "city": "Wonderland"
    }
}
'''
json_str2 = '''
{
    "name": "Bob",
    "age": 25,
    "isStudent": true,
    "courses": ["History", "Art"],
    "address": {
        "street": "456 Oak Ave",
        "city": "Dreamland"
    }
}
'''
json_str3 = '''
{
    "name": "Charlie",
    "age": "forty",  # age是字符串，与json1不同
    "isStudent": false,
    "courses": ["Music"],
    "address": {
        "street": "789 Pine Rd",
        "city": "Storyland"
    }
}
'''
json_str4 = '''
{
    "name": "David",
    "age": 35,
    "isStudent": false,
    "address": {  # 缺少courses字段
        "street": "101 Elm Blvd",
        "city": "Fairyland"
    }
}
'''
json_obj1 = json.loads(json_str1)
json_obj2 = json.loads(json_str2)
json_obj3 = json.loads(json_str3)
json_obj4 = json.loads(json_str4)
print(f"json1 and json2 structure same: {is_json_structure_same(json_obj1, json_obj2)}")  # True
print(f"json1 and json3 structure same: {is_json_structure_same(json_obj1, json_obj3)}")  # False (age类型不同)
print(f"json1 and json4 structure same: {is_json_structure_same(json_obj1, json_obj4)}")  # False (缺少courses字段)

转换为结构描述符后比较

这种方法先将JSON对象转换成一个描述其结构的“签名”或“模式”，然后比较这两个签名是否相同。

思路：

1. 定义一个函数,将JSON对象转换为一个结构描述符。
   • 对象：{"type": "object", "fields": {"field1": descriptor1, "field2": descriptor2, ...}} (字段名排序后处理以保证顺序无关)
   • 数组：{"type": "array", "elementType": descriptor} (描述数组元素的结构)
   • 字符串：{"type": "string"}
   • 数字：{"type": "number"}
   • 布尔值：{"type": "boolean"}
   • null：{"type": "null"}
2. 分别为两个JSON对象生成结构描述符。
3. 比较这两个描述符是否完全相同（可以使用JSON序列化后字符串比较，或深度比较）。

Python示例代码：

import json
from collections import OrderedDict
def get_structure_descriptor(obj):
    if isinstance(obj, dict):
        # 使用OrderedDict保持字段名顺序一致，便于比较
        fields = OrderedDict()
        for key in sorted(obj.keys()):  # 对键排序，确保不同顺序的字段生成相同描述
            fields[key] = get_structure_descriptor(obj[key])
        return {"type": "object", "fields": fields}
    elif isinstance(obj, list):
        if not obj:  # 空数组，元素类型视为null
            return {"type": "array", "elementType": {"type": "null"}}
        # 假设数组所有元素结构相同，取第一个元素的描述
        # 如果需要严格对应位置元素结构相同，此方法需调整
        return {"type": "array", "elementType": get_structure_descriptor(obj[0])}
    elif isinstance(obj, str):
        return {"type": "string"}
    elif isinstance(obj, (int, float)):
        return {"type": "number"}
    elif isinstance(obj, bool):
        return {"type": "boolean"}
    elif obj is None:
        return {"type": "null"}
    else:
        raise TypeError(f"Unsupported type: {type(obj)}")
def are_structures_same_desc(desc1, desc2):
    if desc1["type"] != desc2["type"]:
        return False
    if desc1["type"] == "object":
        if set(desc1["fields"].keys()) != set(desc2["fields"].keys()):
            return False
        for key in desc1["fields"]:
            if not are_structures_same_desc(desc1["fields"][key], desc2["fields"][key]):
                return False
        return True
    elif desc1["type"] == "array":
        return are_structures_same_desc(desc1["elementType"], desc2["elementType"])
    else:  # 基本类型，类型相同即结构相同
        return True
def is_json_structure_same_via_descriptor(json1, json2):
    desc1 = get_structure_descriptor(json1)
    desc2 = get_structure_descriptor(json2)
    return are_structures_same_desc(desc1, desc2)
# 使用前面的json_obj1, json_obj2, json_obj3, json_obj4
print(f"\nUsing descriptor method:")
print(f"json1 and json2 structure same: {is_json_structure_same_via_descriptor(json_obj1, json_obj2)}")