两个json怎么拼接

两个JSON对象如何高效拼接：方法与最佳实践

在数据交互与处理的场景中,JSON（JavaScript Object Notation）以其轻量级、易读易写的特性成为主流的数据交换格式，实际开发中，我们常常需要将两个或多个JSON对象合并为一个，以满足数据扩展、接口响应整合等需求，本文将系统介绍两种JSON拼接的核心方法（代码层拼接与工具库拼接），分析不同场景下的选择策略，并总结关键注意事项。

理解JSON拼接的本质：从“对象合并”说起

JSON（全称“JavaScript Object Notation”）是一种数据格式，而真正参与操作的是其对应的JavaScript对象（或Python中的字典、Java中的Map等）。“JSON拼接”本质上是将两个或多个JSON对象合并为一个新对象，合并过程中需处理键名冲突、嵌套结构等复杂情况。

有两个JSON对象：

{
  "name": "Alice",
  "age": 25,
  "contact": {
    "email": "alice@example.com"
  }
}

和

{
  "age": 26,
  "city": "New York",
  "contact": {
    "phone": "1234567890"
  }
}

合并后可能得到：

{
  "name": "Alice",
  "age": 26, // 键冲突时，后者的值覆盖前者
  "contact": {
    "email": "alice@example.com",
    "phone": "1234567890" // 嵌套对象也需要合并
  },
  "city": "New York"
}

代码层实现：原生语言的合并方法

不同编程语言提供了原生语法或API来实现对象合并,以下是常见语言的实现方式。

JavaScript/TypeScript：展开运算符与Object.assign()

JavaScript中合并对象最常用的两种方式是展开运算符（...）和Object.assign()。

（1）展开运算符（ES6+）

展开运算符可以快速展开对象的所有键值对,适用于浅层合并（嵌套对象仍需额外处理）：

const obj1 = { name: "Alice", age: 25, contact: { email: "alice@example.com" } };
const obj2 = { age: 26, city: "New York", contact: { phone: "1234567890" } };
// 浅层合并：obj2的键覆盖obj1的同名键
const merged = { ...obj1, ...obj2 };
console.log(merged);
// 输出：{ name: "Alice", age: 26, city: "New York", contact: { phone: "1234567890" } }
// 注意：嵌套的contact对象被obj2的contact完全覆盖，未保留obj1的email

若需深度合并（递归合并嵌套对象），需手动实现或借助工具函数：

function deepMerge(target, source) {
  for (const key in source) {
    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
      if (!target[key]) target[key] = {};
      deepMerge(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}
const deepMerged = deepMerge({ ...obj1 }, obj2);
console.log(deepMerged);
// 输出：{ name: "Alice", age: 26, city: "New York", contact: { email: "alice@example.com", phone: "1234567890" } }

（2）Object.assign()

Object.assign()用于将源对象的所有可枚举属性复制到目标对象，同样默认浅层合并：

const target = { name: "Alice" };
const source = { age: 25, city: "New York" };
const merged = Object.assign(target, source);
console.log(merged); // 输出：{ name: "Alice", age: 25, city: "New York" }
// 注意：Object会修改target对象，若需保留原对象，可传入空对象作为目标：Object.assign({}, target, source)

Python：字典合并的多种语法

Python中JSON对象对应字典,合并字典的方式从Python 3.5到3.10不断优化，主要有以下几种：

（1）解包运算符（Python 3.5+）

Python 3.5+支持使用解包字典，语法简洁：

obj1 = {"name": "Alice", "age": 25, "contact": {"email": "alice@example.com"}}
obj2 = {"age": 26, "city": "New York", "contact": {"phone": "1234567890"}}
# 浅层合并
merged = {**obj1, **obj2}
print(merged)
# 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'contact': {'phone': '1234567890'}}

（2）dict.update()方法

update()方法直接修改原字典，适合原地合并：

obj1 = {"name": "Alice", "age": 25}
obj2 = {"age": 26, "city": "New York"}
obj1.update(obj2)
print(obj1)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

（3）合并运算符（Python 3.9+）

Python 3.9引入了和运算符，可读性更强：

obj1 = {"name": "Alice", "age": 25}
obj2 = {"age": 26, "city": "New York"}
merged = obj1 | obj2  # 创建新字典
print(merged)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}
obj1 |= obj2   # 原地修改obj1
print(obj1)    # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

（4）深度合并

Python中深度合并需借助递归或第三方库（如deepmerge），手动实现示例：

def deep_merge_dict(target, source):
    for key, value in source.items():
    if key in target and isinstance(target[key], dict) and isinstance(value, dict):
        deep_merge_dict(target[key], value)
    else:
        target[key] = value
    return target
obj1 = {"name": "Alice", "contact": {"email": "alice@example.com"}}
obj2 = {"contact": {"phone": "1234567890"}, "city": "New York"}
deep_merged = deep_merge_dict(obj1.copy(), obj2)  # 避免修改原字典
print(deep_merged)
# 输出：{'name': 'Alice', 'contact': {'email': 'alice@example.com', 'phone': '1234567890'}, 'city': 'New York'}

Java：Map接口与工具类

Java中JSON对象通常通过Map<String, Object>或第三方库（如Jackson、Gson）表示，合并方式如下：

（1）使用Map的putAll()方法

putAll()方法将一个Map的所有键值对复制到另一个Map中，浅层合并：

import java.util.HashMap;
import java.util.Map;
public class JsonMerge {
    public static void main(String[] args) {
        Map<String, Object> obj1 = new HashMap<>();
        obj1.put("name", "Alice");
        obj1.put("age", 25);
        obj1.put("contact", new HashMap<String, Object>() {{
            put("email", "alice@example.com");
        }});
        Map<String, Object> obj2 = new HashMap<>();
        obj2.put("age", 26);
        obj2.put("city", "New York");
        obj2.put("contact", new HashMap<String, Object>() {{
            put("phone", "1234567890");
        }});
        // 浅层合并
        obj1.putAll(obj2);
        System.out.println(obj1);
        // 输出：{name=Alice, age=26, city=New York, contact={phone=1234567890}}
    }
}

（2）使用第三方库（如Jackson）

若JSON数据通过Jackson的ObjectNode表示，可直接调用setAll()方法：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class JacksonMerge {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode obj1 = mapper.readTree("{\"name\":\"Alice\",\"age\":25,\"contact\":{\"email\":\"alice@example.com\"}}");
        JsonNode obj2 = mapper.readTree("{\"age\":26,\"city\":\"New York\",\"contact\":{\"phone\":\"1234567890\"}}");