高效处理 TypeScript 中两个大型对象数组的迭代与合并
在 TypeScript 开发场景中，我们经常会遇到需要同时处理两个大型对象数组的情况，比如合并用户基础信息和用户扩展信息、拼接订单主表和订单明细表数据等。如果直接采用嵌套循环的方式处理，时间复杂度会达到 O(n*m)，当数组长度达到上万甚至更多时，性能会出现明显瓶颈。本文将介绍几种高效的处理方式，帮你在处理大型数组时提升代码性能。
问题分析
假设我们有两个对象数组，分别是用户基础信息数组 baseUserList 和用户扩展信息数组 extUserList，两个数组的对象都包含唯一的 userId 字段，我们需要根据 userId 将两个数组的对象合并成一个新的对象数组。如果使用最基础的嵌套循环实现，代码逻辑如下：
// 定义用户基础信息类型
type BaseUser = {
userId: string;
name: string;
age: number;
}
// 定义用户扩展信息类型
type ExtUser = {
userId: string;
email: string;
phone: string;
}
// 定义合并后的用户类型
type MergedUser = BaseUser & ExtUser;
// 模拟两个大型数组，这里假设各有10000条数据
const baseUserList: BaseUser[] = Array.from({ length: 10000 }, (_, i) => ({
userId: `user_${i}`,
name: `用户${i}`,
age: 18 + (i % 30)
}));
const extUserList: ExtUser[] = Array.from({ length: 10000 }, (_, i) => ({
userId: `user_${i}`,
email: `user${i}@ipipp.com`,
phone: `1380000${i.toString().padStart(4, '0')}`
}));
// 嵌套循环合并（低效方式）
function mergeByNestedLoop(baseList: BaseUser[], extList: ExtUser[]): MergedUser[] {
const result: MergedUser[] = [];
for (const baseItem of baseList) {
for (const extItem of extList) {
if (baseItem.userId === extItem.userId) {
result.push({ ...baseItem, ...extItem });
break;
}
}
}
return result;
}
// 执行合并
const mergedResult1 = mergeByNestedLoop(baseUserList, extUserList);
console.log(`嵌套循环合并结果长度：${mergedResult1.length}`);这种方式的时间复杂度是 O(n*m)，当 n 和 m 都是 10000 时，循环次数会达到 1 亿次，执行耗时可能超过 1 秒，对于前端交互来说会造成明显的卡顿，后端接口也会响应变慢。
方案一：使用 Map 做哈希映射优化
我们可以先将其中一个数组转换为 Map 结构，以关联字段（这里是 userId）作为键，对象本身作为值。然后再遍历另一个数组，直接从 Map 中取值匹配，这样时间复杂度可以降到 O(n + m)，性能会有质的提升。
// 基于Map的合并方式（高效方式）
function mergeByMap(baseList: BaseUser[], extList: ExtUser[]): MergedUser[] {
// 先将扩展信息数组转为Map，userId作为键
const extMap = new Map<string, ExtUser>();
for (const extItem of extList) {
extMap.set(extItem.userId, extItem);
}
const result: MergedUser[] = [];
// 遍历基础信息数组，直接从Map中匹配
for (const baseItem of baseList) {
const extItem = extMap.get(baseItem.userId);
if (extItem) {
result.push({ ...baseItem, ...extItem });
}
}
return result;
}
// 执行合并
const mergedResult2 = mergeByMap(baseUserList, extUserList);
console.log(`Map方式合并结果长度：${mergedResult2.length}`);这种方式只需要遍历两次数组，第一次构建 Map 是 O(m)，第二次遍历匹配是 O(n)，总体时间复杂度是 O(n + m)，对于 10000 条数据的数组，执行耗时通常在几毫秒以内，性能提升非常明显。
方案二：先排序再双指针遍历
如果两个数组已经按照关联字段排序完成，或者我们可以先对数组进行排序，那么可以采用双指针的方式遍历。双指针遍历的思路是分别用两个指针指向两个数组的起始位置，比较当前指针指向对象的 userId，如果相等就合并，不相等则移动较小的那个指针，直到遍历完任意一个数组。
// 基于排序+双指针的合并方式（适合已排序数组）
function mergeBySortedPointer(baseList: BaseUser[], extList: ExtUser[]): MergedUser[] {
// 先按userId排序，排序时间复杂度是O(nlogn + mlogm)
const sortedBase = [...baseList].sort((a, b) => a.userId.localeCompare(b.userId));
const sortedExt = [...extList].sort((a, b) => a.userId.localeCompare(b.userId));
const result: MergedUser[] = [];
let i = 0; // 基础数组指针
let j = 0; // 扩展数组指针
while (i < sortedBase.length && j < sortedExt.length) {
const baseItem = sortedBase[i];
const extItem = sortedExt[j];
if (baseItem.userId === extItem.userId) {
// userId相等，合并对象
result.push({ ...baseItem, ...extItem });
i++;
j++;
} else if (baseItem.userId < extItem.userId) {
// 基础数组的userId更小，移动基础数组指针
i++;
} else {
// 扩展数组的userId更小，移动扩展数组指针
j++;
}
}
return result;
}
// 执行合并
const mergedResult3 = mergeBySortedPointer(baseUserList, extUserList);
console.log(`排序+双指针方式合并结果长度：${mergedResult3.length}`);这种方式的排序阶段时间复杂度是 O(nlogn + mlogm)，遍历阶段是 O(n + m)，整体性能也不错。不过如果数组本身没有排序，排序的开销会比直接构建 Map 更高一些，适合已经排序好的数组场景。
两种方案的选择建议
我们可以根据实际场景选择合适的方案：
- 如果数组没有排序，优先选择 Map 映射的方式，不需要额外排序，实现简单且性能稳定。
- 如果数组已经按照关联字段排序完成，或者排序操作的成本可以接受（比如数据量不大），可以选择双指针方式，不需要额外创建 Map 结构，更节省内存。
- 如果两个数组中存在重复关联字段的场景，上面的示例逻辑会默认合并第一个匹配到的对象，如果需要处理重复字段，可以在匹配时增加去重或者合并逻辑。
注意事项
在处理大型数组时，除了选择合适的算法，还要注意以下几点：
- 避免在循环中进行不必要的对象创建或者函数调用，减少额外开销。
- 如果数组合并的逻辑只在特定条件下执行，可以先做条件判断，避免无效计算。
- 对于 TypeScript 项目，明确类型定义可以帮助编辑器做类型检查，也能提升代码的可维护性，比如上面的
BaseUser、ExtUser、MergedUser类型定义，能避免合并时出现字段缺失或者类型错误的问题。
通过上面的两种优化方式，我们可以大幅提升 TypeScript 中两个大型对象数组的合并效率，避免性能瓶颈，让代码在实际生产环境中更稳定地运行。
TypeScript数组合并性能优化Map数据结构双指针算法 本作品最后修改时间：2026-05-22 14:28:07