[Python][Go]比较两个JSON文件之间的差异

前言

前段时间同事说他有个需求是比较两个JSON文件之间的差异点，身为DB大神的同事用SQL实现了这个需求，让只会CRUD的我直呼神乎其技。当时用一个一千万多字符、四十多万行的JSON文件来测试，SQL查出来要9秒。周六有时间，拜读了下同事的SQL，打算用Python和Go实现下试试。
测试的json文件如下，其中dst.json从src.json文件复制而来，随便找了个地方改了下。单文件为409510行，字符数为11473154左右。

1. $ wc -ml ./src.json dst.json
2. 409510 11473154 ./src.json
3. 409510 11473155 dst.json
4. 819020 22946309 总计

复制代码

第三方库jsondiff

先在网上搜了下有没有现成的第三方库，找到一个叫jsondiff的第三方python库。使用pip安装后，用法如下

1. import json
2. import jsondiff
3. import os
4. from typing import Any
6. def read_json(filepath: str) -> Any:
7.     if not os.path.exists(filepath):
8.         raise FileNotFoundError(filepath)
9.     try:
10.         with open(filepath, "r") as f:
11.             data = json.load(f)
12.     except json.JSONDecodeError as e:
13.         raise Exception(f"{filepath} is not a valid json file") from e
14.     else:
15.         return data
16.    
17. if __name__ == "__main__":
18.     src_data = read_json("src.json")
19.     dst_data = read_json("dst.json")
21.     diffs = jsondiff.diff(src_data, dst_data)
22.     print(diffs)

复制代码

运行测试

1. $ /usr/bin/time -f 'Elapsed Time: %e s Max RSS: %M kbytes' python third.py
2. {'timepicker': {'time_options': {insert: [(7, '7dd')], delete: [7]}}}
3. Elapsed Time: 1576.30 s Max RSS: 87732 kbytes

复制代码

运行时间太长了，接近半小时，肯定不能拿给别人用。
Python-仅用标准库

只试了jsondiff这一个第三方库，接下来打算直接参考同事那个SQL的思路，自己只用标准库实现一个。

1. from typing import Any, List
2. import json
3. import os
4. from dataclasses import dataclass
5. from collections.abc import MutableSequence, MutableMapping
7. @dataclass
8. class DiffResult:
9.     path: str
10.     kind: str
11.     left: Any
12.     right: Any
14. def add_path(parent: str, key: str) -> str:
15.     """将父路径和key name组合成完整的路径字符串"""
16.     if parent == "":
17.         return key
18.     else:
19.         return parent + "." + key
20.    
21. def read_json(filepath: str) -> Any:
22.     if not os.path.exists(filepath):
23.         raise FileNotFoundError(filepath)
24.     try:
25.         with open(filepath, "r") as f:
26.             data = json.load(f)
27.     except json.JSONDecodeError as e:
28.         raise Exception(f"{filepath} is not a valid json file") from e
29.     else:
30.         return data
31.    
32. def collect_diff(path: str, left: Any, right: Any) -> List[DiffResult]:
33.     """比较两个json数据结构之间的差异
34.    
35.     Args:
36.         path (str): 当前路径
37.         left (Any): 左侧数据
38.         right (Any): 右侧数据
40.     Returns:
41.         List[DiffResult]: 差异列表
42.     """
43.     diffs: List[DiffResult] = []
45.     if isinstance(left, MutableMapping) and isinstance(right, MutableMapping):
46.         # 处理字典：检查 key 的增删改
47.         all_keys = set(left.keys()) | set(right.keys())  # 左右两边字典中所有键的并集，用于后续比较这些键在两个字典中的存在情况及对应的值
48.         for k in all_keys:
49.             l_exists = k in left
50.             r_exists = k in right
51.             key_path = add_path(path, k)
53.             if l_exists and not r_exists:  # 如果一个键只存在于left，则记录为 removed 差异
54.                 diffs.append(DiffResult(key_path, "removed", left=left[k]))
55.             elif not l_exists and r_exists:  # 如果一个键只存在于 right，则记录为 added 差异
56.                 diffs.append(DiffResult(key_path, "added", right=right[k]))
57.             else:
58.                 # 都存在，递归比较这两个键对应的值
59.                 diffs.extend(collect_diff(key_path, left[k], right[k]))
61.     elif isinstance(left, MutableSequence) and isinstance(right, MutableSequence):
62.         # 处理列表：按索引比较
63.         max_len = max(len(left), len(right))  # 找两个列表中最长的长度
64.         for i in range(max_len):
65.             l_exists = i < len(left)
66.             r_exists = i < len(right)
67.             idx_path = f"{path}[{i}]"
69.             lv = left[i] if l_exists else None
70.             rv = right[i] if r_exists else None
72.             if l_exists and not r_exists:  # 某个索引的元素只存在于 left，则记录为 removed 差异
73.                 diffs.append(DiffResult(idx_path, "removed", left=lv))
74.             elif not l_exists and r_exists:  # 某个索引的元素只存在于 right，则记录为 added 差异
75.                 diffs.append(DiffResult(idx_path, "added", right=rv))
76.             else:  # 都存在，递归比较这两个索引对应的值
77.                 diffs.extend(collect_diff(idx_path, lv, rv))
79.     else:
80.         # 基本类型或类型不一致
81.         if left != right:
82.             diffs.append(DiffResult(path, "modified", left=left, right=right))
84.     return diffs
86. if __name__ == "__main__":
87.     src_dict = read_json("src.json")
88.     dst_dict = read_json("dst.json")
90.     diffs = collect_diff("", src_dict, dst_dict)
91.     if len(diffs) == 0:
92.         print("No differences found.")
93.     else:
94.         print(f"Found {len(diffs)} differences:")
95.         for diff in diffs:
96.             match diff.kind:
97.                 case "added":
98.                     print(f"Added: {diff.path}, {diff.right}")
99.                 case "removed":
100.                     print(f"Removed: {diff.path}, {diff.left}")
101.                 case "modified":
102.                     print(f"Modified: {diff.path}, {diff.left} -> {diff.right}")
104.     # print(diffs)

复制代码

运行测试

1. $ /usr/bin/time -f 'Elapsed Time: %e s Max RSS: %M kbytes' python main.py
2. Found 1 differences:
3. Modified: timepicker.time_options[7], 7d -> 7dd
4. Elapsed Time: 0.46 s Max RSS: 87976 kbytes

复制代码

只要 0.46 秒就能比较出来差异点，单论比较性能来说，比jsondiff要好很多。
Go实现

再换go来实现个命令行工具，同样只需要用标准库即可。

1. package main
3. import (
4.         "encoding/json"
5.         "flag"
6.         "fmt"
7.         "io"
8.         "os"
9. )
11. var (
12.         src_file string
13.         dst_file string
14. )
16. type DiffResult struct {
17.         Path  string
18.         Kind  string
19.         Left  any
20.         Right any
21. }
23. func addPath(parent, key string) string {
24.         if parent == "" {
25.                 return key
26.         }
27.         return parent + "." + key
28. }
30. func collectDiff(path string, left, right any) []DiffResult {
31.         var diffs []DiffResult
33.         switch l := left.(type) {
34.         case map[string]any:
35.                 if r, ok := right.(map[string]any); ok {
36.                         for k, lv := range l {
37.                                 rk, exists := r[k]
38.                                 if !exists {
39.                                         diffs = append(diffs, DiffResult{
40.                                                 Path:  addPath(path, k),
41.                                                 Kind:  "removed",
42.                                                 Left:  lv,
43.                                                 Right: nil,
44.                                         })
45.                                 } else {
46.                                         diffs = append(diffs, collectDiff(addPath(path, k), lv, rk)...)
47.                                 }
48.                         }
50.                         for k, rv := range r {
51.                                 if _, exists := l[k]; !exists {
52.                                         diffs = append(diffs, DiffResult{
53.                                                 Path:  addPath(path, k),
54.                                                 Kind:  "added",
55.                                                 Left:  nil,
56.                                                 Right: rv,
57.                                         })
58.                                 }
59.                         }
60.                 } else {
61.                         diffs = append(diffs, DiffResult{
62.                                 Path:  path,
63.                                 Kind:  "modified",
64.                                 Left:  left,
65.                                 Right: right,
66.                         })
67.                 }
68.         case []any:
69.                 if r, ok := right.([]any); ok {
70.                         // 比较 slice（这里简化：按索引比较）
71.                         maxLen := len(l)
72.                         if len(r) > maxLen {
73.                                 maxLen = len(r)
74.                         }
75.                         for i := 0; i < maxLen; i++ {
76.                                 var lv, rv any
77.                                 var lExists, rExists bool
79.                                 if i < len(l) {
80.                                         lv = l[i]
81.                                         lExists = true
82.                                 }
83.                                 if i < len(r) {
84.                                         rv = r[i]
85.                                         rExists = true
86.                                 }
88.                                 switch {
89.                                 case lExists && !rExists:
90.                                         diffs = append(diffs, DiffResult{
91.                                                 Path:  fmt.Sprintf("%s[%d]", path, i),
92.                                                 Kind:  "removed",
93.                                                 Left:  lv,
94.                                                 Right: nil,
95.                                         })
96.                                 case !lExists && rExists:
97.                                         diffs = append(diffs, DiffResult{
98.                                                 Path:  fmt.Sprintf("%s[%d]", path, i),
99.                                                 Kind:  "added",
100.                                                 Left:  nil,
101.                                                 Right: rv,
102.                                         })
103.                                 case lExists && rExists:
104.                                         diffs = append(diffs, collectDiff(fmt.Sprintf("%s[%d]", path, i), lv, rv)...)
105.                                 }
106.                         }
107.                 } else {
108.                         diffs = append(diffs, DiffResult{
109.                                 Path:  path,
110.                                 Kind:  "modified",
111.                                 Left:  left,
112.                                 Right: right,
113.                         })
114.                 }
115.         default:
116.                 if fmt.Sprintf("%v", left) != fmt.Sprintf("%v", right) {
117.                         diffs = append(diffs, DiffResult{
118.                                 Path:  path,
119.                                 Kind:  "modified",
120.                                 Left:  left,
121.                                 Right: right,
122.                         })
123.                 }
124.         }
125.         return diffs
126. }
128. func readJSON(r io.Reader) (map[string]any, error) {
129.         var data map[string]any
130.         decoder := json.NewDecoder(r)
131.         if err := decoder.Decode(&data); err != nil {
132.                 return nil, err
133.         }
134.         return data, nil
135. }
137. func main() {
138.         flag.StringVar(&src_file, "src", "src.json", "source file")
139.         flag.StringVar(&dst_file, "dst", "dst.json", "destination file")
140.         flag.Parse()
141.         srcFile, err := os.Open(src_file)
142.         if err != nil {
143.                 fmt.Fprintf(os.Stderr, "Error opening src.json: %v\n", err)
144.                 return
145.         }
146.         defer srcFile.Close()
148.         dstFile, err := os.Open(dst_file)
149.         if err != nil {
150.                 fmt.Fprintf(os.Stderr, "Error opening dst.json: %v\n", err)
151.                 return
152.         }
153.         defer dstFile.Close()
155.         srcJson, err := readJSON(srcFile)
156.         if err != nil {
157.                 fmt.Fprintf(os.Stderr, "Error reading src.json: %v\n", err)
158.                 return
159.         }
160.         dstJson, err := readJSON(dstFile)
161.         if err != nil {
162.                 fmt.Fprintf(os.Stderr, "Error reading dst.json: %v\n", err)
163.                 return
164.         }
165.         diffs := collectDiff("", srcJson, dstJson)
166.         if len(diffs) == 0 {
167.                 fmt.Println("No differences found.")
168.         } else {
169.                 fmt.Printf("%d differences found:\n", len(diffs))
170.                 for _, diff := range diffs {
171.                         switch diff.Kind {
172.                         case "added":
173.                                 fmt.Printf("Added: %s: %v\n", diff.Path, diff.Right)
174.                         case "removed":
175.                                 fmt.Printf("Removed: %s: %v\n", diff.Path, diff.Left)
176.                         case "modified":
177.                                 fmt.Printf("Modified: %s: %v -> %v\n", diff.Path, diff.Left, diff.Right)
178.                         }
179.                 }
180.         }
181. }

复制代码

运行测试，速度同样很快。

1. $ /usr/bin/time -f 'Elapsed Time: %e s Max RSS: %Mkbytes' ./diffjson -src ./src.json -dst ./dst.json
2. 1 differences found:
3. Modified: timepicker.time_options[7]: 7d -> 7dd
4. Elapsed Time: 0.29 s Max RSS: 117468 kbytes

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！