通过2个不同的键比较2个对象数组.并制作一个包含父对象和子对象的嵌套对象

Question

我在比较两个对象数组时遇到问题。我在搜索lodash文档，但找不到合适的方法。问题是，我需要通过不同的键来比较对象。

private parentArray: {}[] = [
{ Id: 1, Name: 'A' },
{ Id: 2, Name: 'B' },
{ Id: 3, Name: 'C' },
{ Id: 4, Name: 'D' }
];
private childArray: {}[] = [
{ Id: 2, parentId: 2, Name: 'a' },
{ Id: 3, parentId: 2, Name: 'b' },
{ Id: 4, parentId: 4, Name: 'c' },
{ Id: 5, parentId: 4, Name: 'd' }
];

我需要制作一个新的嵌套对象数组，其中"parentId"将与父对象的"Id"匹配，如下所示：

private newArray = [
{ Id: 1, Name: 'A', Children: [] },
{
Id: 2,
Name: 'B',
Children: [
{ Id: 2, parentId: 2, Name: 'a' },
{ Id: 3, parentId: 2, Name: 'b' }
]
},
{
Id: 3,
Name: 'C',
Children: []
},
{
Id: 4,
Name: 'D',
Children: [
{ Id: 4, parentId: 4, Name: 'c' },
{ Id: 5, parentId: 4, Name: 'd' }
]
}
];

我使用了'.intersectionWith([arrays]，[pcomparator])'和'.isMatchWith(object，source，[customizer])'，但它没有提供我需要的东西。如果有任何帮助，我将不胜感激。

Answer 1

最简单的方法可能是

const newArray = parentArray.map(
p => ({ ...p, Children: childArray.filter(c => c.parentId === p.Id) })
)

从而得到您要查找的输出。注意，在parentArray和childArray较大的情况下，这不一定是性能最好的算法，因为我们对parentArray中的每个元素都在整个childArray上循环(因此，如果childArray是长度，parentArray是长度，则该算法是O(×))。

如果这样的性能很重要，那么您可以通过在childArray和parentArray中的每个元素上迭代一次来实现这一点(这是O(+)，假设哈希查找是O1)，如下所示：

type Parent = typeof parentArray[number];
type Child = typeof childArray[number];
interface New extends Parent {
Children: Child[];
}
const newArray: New[] = [];
const parentLookup: Record<number, New> = {};    
for (const p of parentArray) {
const n = { ...p, Children: [] };
newArray.push(n)
parentLookup[p.Id] = n;
}
for (const c of childArray) {
parentLookup[c.parentId]?.Children.push(c);
}
console.log(newArray);

游乐场链接到代码

Answer 2

type Parent = {
Id: number,
Name: string,
}
type Child = Parent & {
parentId: number;
}
type ParentAndChildren = {
Children: Child[]
} & Parent

const parents: Parent[] = [
{ Id: 1, Name: 'A' },
{ Id: 2, Name: 'B' },
{ Id: 3, Name: 'C' },
{ Id: 4, Name: 'D' }
];
const children: Child[] = [
{ Id: 2, parentId: 2, Name: 'a' },
{ Id: 3, parentId: 2, Name: 'b' },
{ Id: 4, parentId: 4, Name: 'c' },
{ Id: 5, parentId: 4, Name: 'd' }
];
const output = parents.map((p: Parent): ParentAndChildren => {
return {
Id: p.Id,
Name: p.Name,
Children: children.filter((c) => p.Id === c.parentId),
}
})
console.log(output);