Javascript 在对象数组的数组中查找对象

我目前有一个对象数组，每个对象都包含一个对象数组

我的目标是在一行javascript代码中找到一个

嵌套对象。我试图避免嵌套循环，我知道如何用这种方式解决它，但javascript为这种情况提供了许多优雅的解决方案

我的数据就是这样的：

const items = [
    {
        id: 1,
        title: 'Test 1',
        data: [
            {
                id: 3,
                title: 'Test 3',
            },
            {
                id: 4,
                title: 'Test 4',
            },
        ],
    },
    {
        id: 2,
        title: 'Test 2',
        data: [
            {
                id: 5,
                title: 'Test 5',
            },
        ],
    },
];

let item = null;
for (let i = 0; i<items.length; i++) {
    for (let j = 0; j<items[i].data; j++) {
        if (items[i].data[j].id == myId) {
            item = items[i].data[j];
            return;
        }
    }
}

带有嵌套循环：

const items = [
    {
        id: 1,
        title: 'Test 1',
        data: [
            {
                id: 3,
                title: 'Test 3',
            },
            {
                id: 4,
                title: 'Test 4',
            },
        ],
    },
    {
        id: 2,
        title: 'Test 2',
        data: [
            {
                id: 5,
                title: 'Test 5',
            },
        ],
    },
];

let item = null;
for (let i = 0; i<items.length; i++) {
    for (let j = 0; j<items[i].data; j++) {
        if (items[i].data[j].id == myId) {
            item = items[i].data[j];
            return;
        }
    }
}

let item=null；
对于（设i=0；i可以在一行中完成。正如我在嵌套循环解决方案中看到的，可以在每个对象的数据中找到，因此首先可以将数据展平到对象数组中，然后通过该数组进行查找


const项=[
{
id:1，
标题：“测试1”，
数据：[
{
id:3，
标题：“测试3”，
},
{
id:4，
标题：“测试4”，
},
],
},
{
id:2，
标题：“测试2”，
数据：[
{
id:5，
标题：“测试5”，
},
],
},
];
常数myId=4；
const res=items.flatMap（（item）=>item.data）.find（{id}）=>id==myId）；
console.log（res）；
您可以在一行中完成此操作。正如我在嵌套循环解决方案中看到的，您可以在每个对象的数据中找到，因此首先可以将数据展平到对象数组中，然后通过该数组进行查找


const项=[
{
id:1，
标题：“测试1”，
数据：[
{
id:3，
标题：“测试3”，
},
{
id:4，
标题：“测试4”，
},
],
},
{
id:2，
标题：“测试2”，
数据：[
{
id:5，
标题：“测试5”，
},
],
},
];
常数myId=4；
const res=items.flatMap（（item）=>item.data）.find（{id}）=>id==myId）；
console.log（res）；
在性能方面，我建议结合使用


const items=[{id:1，标题：“测试1”，数据：[{id:3，标题：“测试3”，}，{id:4，标题：“测试4”，}，}，}，{id:2，标题：“测试2”，数据：[{id:5，标题：“测试5”，}，}，}，]；
常数myId=4；
const res=items.reduce（（acc，{data}）=>{
const foundItem=data.find（（{id}）=>id==myId）；
如果（项目）
acc.push（基础项目）；
返回acc；
}, [])
console.log（res）；
在性能方面，我建议结合使用


const items=[{id:1，标题：“测试1”，数据：[{id:3，标题：“测试3”，}，{id:4，标题：“测试4”，}，}，}，{id:2，标题：“测试2”，数据：[{id:5，标题：“测试5”，}，}，}，]；
常数myId=4；
const res=items.reduce（（acc，{data}）=>{
const foundItem=data.find（（{id}）=>id==myId）；
如果（项目）
acc.push（基础项目）；
返回acc；
}, [])
console.log（res）；
你能使用吗？我知道如何在平面结构上使用它，但我不确定嵌套结构。你介意详细说明一下吗？如果这是一个愚蠢的问题，很抱歉，我不是javascript方面的专家。
const item=items.find（（parent）=>parent.data.find（（child）=>child.id==id））这是我尝试过的，但它返回了父项及其所有子项。
let item；for（const{data}of items）{if（item=data.find（e=>e.id==myID））break；}
，或者为它编写一个更通用的函数。为什么要在其中一个代码中使用它？重点是优化逻辑，而不是代码行。你能使用吗？我知道如何在平面结构上使用它，但我不确定嵌套结构。你介意详细说明吗？如果这是一个愚蠢的问题，很抱歉，我不是javascript方面的专家。
const item=items.find（（parent）=>parent.data.find（（child）=>child.id==id））；
这是我尝试过的，但它返回了父级及其所有子级。
let item；for（items的const{data}）{if（item=data.find（e=>e.id==myID））break；}
，或者为其编写一个更通用的函数。为什么要在其中一个代码中使用它？重点是优化逻辑，而不是代码行。好的解决方案。只是一个小标注，这在IE中不受支持。如果这不是问题，那么这将是一个好的选择-好的解决方案。只是一个小标注，这在IE中不受支持。如果这不是问题m、 那么这将是一个很好的选择-