如何将具有相同 amendment 值的数组对象合并为单一对象

在前端开发中，我们经常会拿到一个包含多个对象的数组，这些对象中存在amendment值相同的条目，需要将这些相同amendment值的对象合并成单个对象，比如合并相同标识的配置项、聚合相同分类的业务数据等。不同业务对合并后的字段处理逻辑不同，下面介绍几种通用的实现方案。

方案一：使用哈希表存储合并结果

这种方案的核心是先创建一个空对象作为哈希表，遍历原数组时，以amendment值为键判断哈希表中是否已存在对应条目，不存在则直接存入，存在则按照规则合并字段。

// 原始数组数据
const originArr = [
    { amendment: 'a1', name: '配置1', value: 10 },
    { amendment: 'a1', name: '配置1更新', value: 20 },
    { amendment: 'a2', name: '配置2', value: 30 },
    { amendment: 'a2', name: '配置2', value: 40 }
];

// 合并规则：保留同amendment值中最后出现的对象，覆盖之前的字段
const mergeByAmendment = (arr) => {
    const hashMap = {};
    arr.forEach(item => {
        const key = item.amendment;
        if (hashMap[key]) {
            // 合并字段，这里示例为覆盖已有字段，也可以自定义合并逻辑
            hashMap[key] = { ...hashMap[key], ...item };
        } else {
            hashMap[key] = { ...item };
        }
    });
    // 将哈希表的值转为数组返回
    return Object.values(hashMap);
};

const result1 = mergeByAmendment(originArr);
console.log(result1);
// 输出：[
//   { amendment: 'a1', name: '配置1更新', value: 20 },
//   { amendment: 'a2', name: '配置2', value: 40 }
// ]

方案二：数值型字段累加合并

如果合并时需要将相同amendment值的数值型字段累加，比如统计同分类下的数量总和，可以调整合并逻辑，对特定字段做累加处理。

const originArr = [
    { amendment: 'a1', count: 5, price: 100 },
    { amendment: 'a1', count: 3, price: 100 },
    { amendment: 'a2', count: 2, price: 200 },
    { amendment: 'a2', count: 4, price: 200 }
];

const mergeWithSum = (arr, sumFields) => {
    const hashMap = {};
    arr.forEach(item => {
        const key = item.amendment;
        if (hashMap[key]) {
            // 对需要累加的字段做处理
            sumFields.forEach(field => {
                if (typeof item[field] === 'number') {
                    hashMap[key][field] += item[field];
                }
            });
            // 非累加字段保留最新的
            sumFields.forEach(field => {
                delete item[field];
            });
            hashMap[key] = { ...hashMap[key], ...item };
        } else {
            hashMap[key] = { ...item };
        }
    });
    return Object.values(hashMap);
};

// 指定count字段需要累加
const result2 = mergeWithSum(originArr, ['count']);
console.log(result2);
// 输出：[
//   { amendment: 'a1', price: 100, count: 8 },
//   { amendment: 'a2', price: 200, count: 6 }
// ]

方案三：使用reduce方法简化代码

数组的reduce方法可以更简洁地实现哈希表的逻辑，不需要额外定义哈希表变量，直接在累加器中处理合并逻辑。

const originArr = [
    { amendment: 'a1', tag: '前端' },
    { amendment: 'a1', desc: '开发' },
    { amendment: 'a2', tag: '后端' },
    { amendment: 'a2', desc: '开发' }
];

const mergeByReduce = (arr) => {
    return arr.reduce((acc, cur) => {
        const key = cur.amendment;
        if (acc[key]) {
            acc[key] = { ...acc[key], ...cur };
        } else {
            acc[key] = { ...cur };
        }
        return acc;
    }, {});
};

const result3 = Object.values(mergeByReduce(originArr));
console.log(result3);
// 输出：[
//   { amendment: 'a1', tag: '前端', desc: '开发' },
//   { amendment: 'a2', tag: '后端', desc: '开发' }
// ]

方案对比与选择

三种方案的核心逻辑都是利用哈希表来快速查找相同amendment值的对象，只是实现方式不同：

• 方案一逻辑最直观，适合新手理解，代码可读性高
• 方案二适合有数值累加需求的场景，可灵活配置需要累加的字段
• 方案三代码更简洁，适合熟悉reduce方法的开发者使用

实际使用时可以根据合并规则调整字段处理逻辑，比如如果需要保留所有历史值，可以将对应字段设为数组，合并时把新值push到数组中即可。

JavaScript数组对象合并amendment对象去重修改时间：2026-07-07 01:03:14