怎么去掉json重复key

如何有效处理JSON中的重复Key问题

在开发过程中,JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，被广泛应用于前后端数据交互、配置文件存储等场景，由于数据来源复杂（如多个API合并、手动输入错误、数据解析异常等），JSON中偶尔会出现重复Key的情况——即同一个Key在同一个对象中出现多次。

{
  "name": "Alice",
  "age": 25,
  "name": "Bob",
  "city": "New York"
}

这种重复Key会导致数据解析时的歧义：大多数JSON解析器（如JavaScript的JSON.parse()）会保留最后一个Key的值，覆盖前面的值，但这可能不符合业务逻辑（如需要保留所有值或特定位置的值），正确处理JSON重复Key是数据清洗和规范化的重要环节，本文将详细介绍重复Key的成因、影响及多种处理方法。

JSON重复Key的成因与常见场景

了解重复Key的来源有助于从源头减少问题,常见的成因包括：

数据源合并错误：当多个JSON对象或数组合并时，若未对Key去重，可能导致重复，将两个用户列表合并时，若存在相同的用户ID，可能会重复"id"、"name"等Key。
手动输入或生成错误：在手动编写JSON或通过脚本生成时，可能因疏忽重复输入某个Key。
解析异常：某些JSON解析器在处理不规范格式时（如未使用引号包裹Key），可能错误解析为重复Key。
业务逻辑冲突：日志数据中同一事件可能被多次记录，导致相同Key重复出现。

处理JSON重复Key的核心方法

根据业务需求（如保留第一个值、最后一个值、合并值或报错），可选择不同的处理方法，以下是几种主流方案，涵盖编程语言实现和工具辅助。

方法1：编程语言处理（通用且灵活）

通过代码处理是最常见的方式,可根据需求自定义保留逻辑，以下是Python、JavaScript和Java的实现示例。

Python实现

Python的json模块本身会保留最后一个Key的值，但我们可以通过字典（dict）的特性（Key唯一性）或手动解析来实现自定义逻辑。

场景1：保留最后一个Key的值（默认行为）
直接使用json.loads()解析，Python会自动覆盖重复Key：

import json
json_str = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}'
data = json.loads(json_str)
print(data)  # 输出: {'name': 'Bob', 'age': 25, 'city': 'New York'}

场景2：保留第一个Key的值
通过遍历JSON对象，手动构建字典并跳过重复Key：

import json
def keep_first_key(json_str):
    data = json.loads(json_str)
    unique_data = {}
    seen_keys = set()
    for key, value in data.items():
        if key not in seen_keys:
            unique_data[key] = value
            seen_keys.add(key)
    return unique_data
json_str = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}'
result = keep_first_key(json_str)
print(result)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

场景3：合并重复Key的值（如转为数组）
若业务需要保留所有重复Key的值，可将值转为列表：

import json
def merge_duplicate_keys(json_str):
    data = json.loads(json_str)
    merged_data = {}
    for key, value in data.items():
        if key in merged_data:
            if not isinstance(merged_data[key], list):
                merged_data[key] = [merged_data[key]]
            merged_data[key].append(value)
        else:
            merged_data[key] = value
    return merged_data
json_str = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}'
result = merge_duplicate_keys(json_str)
print(result)  # 输出: {'name': ['Alice', 'Bob'], 'age': 25, 'city': 'New York'}

JavaScript实现

JavaScript处理JSON重复Key的逻辑与Python类似,可通过JSON.parse()（默认保留最后一个值）或手动遍历对象实现。

场景1：保留最后一个Key的值（默认行为）

const jsonStr = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}';
const data = JSON.parse(jsonStr);
console.log(data);  // 输出: { name: 'Bob', age: 25, city: 'New York' }

场景2：保留第一个Key的值

function keepFirstKey(jsonStr) {
    const data = JSON.parse(jsonStr);
    const uniqueData = {};
    const seenKeys = new Set();
    for (const [key, value] of Object.entries(data)) {
        if (!seenKeys.has(key)) {
            uniqueData[key] = value;
            seenKeys.add(key);
        }
    }
    return uniqueData;
}
const jsonStr = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}';
const result = keepFirstKey(jsonStr);
console.log(result);  // 输出: { name: 'Alice', age: 25, city: 'New York' }

场景3：合并重复Key的值（转为数组）

function mergeDuplicateKeys(jsonStr) {
    const data = JSON.parse(jsonStr);
    const mergedData = {};
    for (const [key, value] of Object.entries(data)) {
        if (key in mergedData) {
            if (!Array.isArray(mergedData[key])) {
                mergedData[key] = [mergedData[key]];
            }
            mergedData[key].push(value);
        } else {
            mergedData[key] = value;
        }
    }
    return mergedData;
}
const jsonStr = '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}';
const result = mergeDuplicateKeys(jsonStr);
console.log(result);  // 输出: { name: [ 'Alice', 'Bob' ], age: 25, city: 'New York' }

Java实现

Java中可使用org.json库或Jackson/Gson等工具处理JSON重复Key。

场景1：使用org.json库（保留最后一个Key的值）

import org.json.JSONObject;
public class JsonDuplicateKey {
    public static void main(String[] args) {
        String jsonStr = "{\"name\": \"Alice\", \"age\": 25, \"name\": \"Bob\", \"city\": \"New York\"}";
        JSONObject data = new JSONObject(jsonStr);
        System.out.println(data.toString());  // 输出: {"name":"Bob","age":25,"city":"New York"}
    }
}

场景2：保留第一个Key的值（手动遍历）

import org.json.JSONObject;
import java.util.LinkedHashSet;
import java.util.Set;
public class JsonDuplicateKey {
    public static JSONObject keepFirstKey(String jsonStr) {
        JSONObject original = new JSONObject(jsonStr);
        JSONObject unique = new JSONObject();
        Set<String> seenKeys = new LinkedHashSet<>();
        for (String key : original.keySet()) {
            if (!seenKeys.contains(key)) {
                unique.put(key, original.get(key));
                seenKeys.add(key);
            }
        }
        return unique;
    }
    public static void main(String[] args) {
        String jsonStr = "{\"name\": \"Alice\", \"age\": 25, \"name\": \"Bob\", \"city\": \"New York\"}";
        JSONObject result = keepFirstKey(jsonStr);
        System.out.println(result.toString());  // 输出: {"name":"Alice","age":25,"city":"New York"}
    }
}

方法2：使用命令行工具（适合批量处理）

如果需要对大量JSON文件去重,可使用命令行工具（如jq、sed等），高效且无需编写代码。

使用`jq`工具（推荐）

jq是一个轻量级的JSON命令行处理器，支持强大的过滤和转换功能。

安装jq：

Linux/macOS：sudo apt-get install jq 或 brew install jq
Windows：从官网下载可执行文件

示例操作：

场景1：保留最后一个Key的值（默认行为）
jq会自动处理重复Key，保留最后一个值：

echo '{"name": "Alice", "age": 25, "name": "Bob", "city": "New York"}' | jq .

输出：

{
  "name": "Bob",
  "age

正文