如何精确判断嵌套List/Map是否完全相等？有无无需外部包的实现？

我有两个嵌套的dynamic类型List（superDeepList1、superDeepList2）和两个嵌套的Map<String, dynamic>（superDeepMap1、superDeepMap2），结构如下：

嵌套List示例 #

List<dynamic> superDeepList1 = [
      [
        {
          'name': 'Alice',
          'age': 30,
          'height': 5.8,
          'isStudent': false,
          'friends': ['Bob', 'Carol', 'David'],
          'address': {
            'street': '123 Main St',
            'city': 'Wonderland',
            'zipcode': '12345'
          }
        },
        {
          'name': 'Bob',
          'age': 25,
          'height': 6.1,
          'isStudent': true,
          'friends': ['Alice', 'Carol'],
          'address': {
            'street': '456 Elm St',
            'city': 'Dreamville',
            'zipcode': '54321'
          }
        },
        'This is a string item'
      ],
      [
        {
          'name': 'Carol',
          'age': 28,
          'height': 5.5,
          'isStudent': true,
          'friends': ['Alice', 'Bob', 'David'],
          'address': {
            'street': '789 Oak St',
            'city': 'Fantasia',
            'zipcode': '67890'
          }
        },
        {
          'name': 'David',
          'age': 32,
          'height': 5.9,
          'isStudent': false,
          'friends': ['Alice', 'Carol'],
          'address': {
            'street': '321 Pine St',
            'city': 'Neverland',
            'zipcode': '09876'
          }
        },
        'Another string item'
      ]
    ];

List<dynamic> superDeepList2 = [
  [
    {
      'name': 'Alfdsfe',
      'age': 36,
      'height': 5.8,
      'isStudent': false,
      'friends': ['Bob', 'Carol', 'David'],
      'address': {
        'street': '123 Main St',
        'city': 'Wonderland',
        'zipcode': '12345'
      }
    },
    {
      'name': 'Bob',
      'age': 25,
      'height': 6.1,
      'isStudent': true,
      'friends': ['Alice', 'Carol'],
      'address': {
        'street': '456 Elm St',
        'city': 'Dreamville',
        'zipcode': '54321'
      }
    },
    'This is a string item'
  ],
  [
    {
      'name': 'Carol',
      'age': 28,
      'height': 5.5,
      'isStudent': true,
      'friends': ['Alice', 'Bob', 'David'],
      'address': {
        'street': '789 Oak St',
        'city': 'Fantasia',
        'zipcode': '67890'
      }
    },
    {
      'name': 'David',
      'age': 32,
      'height': 5.9,
      'isStudent': false,
      'friends': ['Alice', 'Carol'],
      'address': {
        'street': '321 Pine St',
        'city': 'Neverland',
        'zipcode': '09876'
      }
    },
    'Another string item'
  ]
];

嵌套Map示例 #

Map<String, dynamic> superDeepMap1 = {
  'outerKey1': {
    'innerKey1': {
      'nestedKey1': 'value1',
      'nestedKey2': 'value2',
      'nestedKey3': {
        'deepNestedKey1': 'deepValue1',
        'deepNestedKey2': 'deepValue2'
      }
    },
    'innerKey2': {
      'nestedKey4': 'value4',
      'nestedKey5': 'value5'
    }
  },
  'outerKey2': {
    'innerKey3': {
      'nestedKey6': 'value6',
      'nestedKey7': 'value7'
    },
    'innerKey4': {
      'nestedKey8': 'value8',
      'nestedKey9': 'value9'
    }
  }
};

Map<String, dynamic> superDeepMap2 = {
  'outerKey1': {
    'innerKey1': {
      'nestedKey1': 'value1',
      'nestedKey2': 'value2',
      'nestedKey3': {
        'deepNestedKey1': 'deepValue1',
        'deepNestedKey2': 'deepValue2'
      }
    },
    'innerKey2': {
      'nestedKey4': 'value4',
      'nestedKey5': 'value5'
    }
  },
  'outerKey2': {
    'innerKey3': {
      'nestedKey6': 'value6',
      'nestedKey7': 'value7'
    },
    'innerKey4': {
      'nestedKey8': 'value8',
      'nestedKey9': 'value9'
    }
  }
};

我需要精确检查superDeepList1与superDeepList2、superDeepMap1与superDeepMap2的长度和内容是否完全一致。目前已经知道可以用collection包实现：

bool listsEqual = const DeepCollectionEquality().equals(superDeepList1,superDeepList2);

但想知道有没有不依赖外部包的简短实现方式。

你可以自己实现一个递归的深度相等检查函数，同时支持List和Map的嵌套比较，代码如下：

bool deepEqual(dynamic a, dynamic b) {
  // 基础类型直接判断相等
  if (a == b) return true;
  
  // 处理嵌套List
  if (a is List && b is List) {
    if (a.length != b.length) return false;
    for (int i = 0; i < a.length; i++) {
      if (!deepEqual(a[i], b[i])) return false;
    }
    return true;
  }
  
  // 处理嵌套Map
  if (a is Map && b is Map) {
    if (a.length != b.length) return false;
    for (final key in a.keys) {
      if (!b.containsKey(key) || !deepEqual(a[key], b[key])) return false;
    }
    return true;
  }
  
  // 其他不匹配类型返回false
  return false;
}

使用方式 #

// 比较两个嵌套List
bool listsEqual = deepEqual(superDeepList1, superDeepList2);
// 比较两个嵌套Map
bool mapsEqual = deepEqual(superDeepMap1, superDeepMap2);

说明 #

• 函数会递归遍历嵌套的List和Map，先检查长度是否一致，再逐一比较内部元素/键值对的内容和结构
• 字符串、数字、布尔值等基础类型直接用==判断相等性
• 完全匹配时返回true，否则返回false

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