通過 2 個不同的鍵比較對象的 2 個 arrays。 並制作一個包含父母和孩子的嵌套 object

Question

我在比較對象的 2 個 arrays 時遇到問題。 我正在搜索 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], [comarator])' 和 '.isMatchWith(object, source, [customizer])' 但它沒有給我我需要的東西。 我將不勝感激任何幫助。

Answer 1

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) => {
    return {
        Id: p.Id,
        Name: p.Name,
        Children: children.filter((c) => p.Id === c.parentId),
    }
})

console.log(output);

Answer 2

最簡單的方法可能是

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

這導致您正在尋找 output。 請注意，在parentArray和childArray很大的情況下，這不一定是性能最好的算法，因為我們正在為parentArray childArray所以如果childArray是 length 並且parentArray是 length 那么這個算法是O (× ））。

如果這樣的性能很重要，那么您可以通過對childArray和parentArray中的每個元素進行一次迭代（即O (+)）來實現，如下所示：

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);

Playground 代碼鏈接