Question

是否有一种方法可以重构此代码，使代码看起来更短且可读？ payload中的ID不会超过100，因此我认为在这种情况下，性能无关紧要。

const payload = {
    RequestIds: [ 
        { Id: 1 },
        { Id: 3 },
    ]
}

const result = {
    Items: [
        { Id: 1, Name: 'Item 1 A'},
        { Id: 1, Name: 'Item 1 B'},
        { Id: 2, Name: 'Item 2 C'},
        { Id: 2, Name: 'Item 2 D'},
        { Id: 3, Name: 'Item 3 E'},
        { Id: 3, Name: 'Item 3 F'},
    ]
}


const items = [];
for(const payloadItem of payload.RequestIds) {
    const filteredItems = result.Items.filter(item => item.Id === payloadItem.Id);

    if (filteredItems.length > 0) {
        items.push(...filteredItems);
    }
}

console.log(items);

Answer 1

在有效负载中制作一组Id，然后通过是否包含要迭代的ID来做一个.filter：

const payload = {
    RequestIds: [ 
        { Id: 1 },
        { Id: 3 },
    ]
};
const payloadIds = new Set(payload.RequestIds.map(({ Id }) => Id));

const result = {
    Items: [
        { Id: 1, Name: 'Item 1 A'},
        { Id: 1, Name: 'Item 1 B'},
        { Id: 2, Name: 'Item 2 C'},
        { Id: 2, Name: 'Item 2 D'},
        { Id: 3, Name: 'Item 3 E'},
        { Id: 3, Name: 'Item 3 F'},
    ]
}

const items = result.Items.filter(({ Id }) => payloadIds.has(Id));
console.log(items);

Answer 2

请尝试这个。

const resultItems = result.Items;
const items = payload.RequestIds.reduce((prev, cur) => [...prev, ...resultItems.filter(item => item.Id === cur.Id)], []);

或

const items = resultItems.filter(item => payload.RequestIds.some(req => req.Id === item.Id));

减少循环逻辑？

2 个答案: