ES6 - 在嵌套数组中查找数据

Question

在使用 find 或 filter 的 ES6 中，我很乐意使用值进行迭代以在数组中查找元素。

但是，我正在尝试根据嵌套数组中的值从父数组中获取值。

例如，在这个数据结构中：

products: [
  {
    id: 01,
    items: [
      {
        id: 01,
        name: 'apple'
      },
      {
        id: 02,
        name: 'banana'
      },
      {
        id: 03,
        name: 'orange'
      }
    ]
  },
  {
    id: 02,
    items: [
      {
        id: 01,
        name: 'carrot'
      },
      {
        id: 02,
        name: 'lettuce'
      },
      {
        id: 03,
        name: 'peas'
      }
    ]
  },
  {
    id: 03,
    items: [
      {
        id: 01,
        name: 'eggs'
      },
      {
        id: 02,
        name: 'bread'
      },
      {
        id: 03,
        name: 'milk'
      }
    ]
  }
]

如果我知道对象milk 的name 或id，有没有办法找出它嵌套在其中的元素的ID？

目前我有这个：

products.find((product) => {
  product.find((prod) => {
    return prod.name === 'milk';
  });
});

只返回包含milk的对象。

Answer 1

直接获取item，不加倍返回获取名称：

let found;
for ( const category of products ){
    found = category.items.find( item => item.name == "milk" )
    if ( found ) break
}
found // == { id: 3, name: 'milk' }

Answer 2

我知道你提到了 ES6，但在这种情况下（如果你想返回内部对象）我相信最好使用 for/of 而不是 map/reduce/find：

for (let p of products) {
  for (let i of p.items) {
    if (i.name === 'milk') return i;
  }
}

Answer 3

接受的答案对我没有用，因为我想要内部查找的结果，同时使用它总是给我外部过滤器/查找的结果，我不得不使用结果数组来查找值再次。

所以我改为使用 reduce 和短路来获得内部结果。

// undefined as the initial value is necessary, otherwise it gets the first value of the array instead.

return products.reduce((prev, product) => prev || product.items.find(item => item.name === 'milk'), undefined);

const products = [
  {id: 1, items: [
    {id: 1, name: 'apple'},
    {id: 2, name: 'banana'},
    {id: 3, name: 'orange'}
  ]},
  {id: 2, items: [
    {id: 1, name: 'carrot'},
    {id: 2, name: 'lettuce'},
    {id: 3, name: 'peas'}
  ]},
  {id: 3, items: [
    {id: 1, name: 'eggs'},
    {id: 2, name: 'bread'},
    {id: 3, name: 'milk'}
  ]}
];

console.log(products.reduce((prev, product) => prev || product.items.find(item => item.name === 'milk'), undefined));

Answer 4

你必须从外部find 的回调中返回一些东西。事实上，对于内部迭代，您不应该使用find，而应该使用some，它返回一个布尔值，用于判断数组中是否存在与条件匹配的元素：

products.find((product) => {
  return product.items.some((item) => {
//^^^^^^
    return item.name === 'milk';
  });
});

或者简而言之：

products.find(product => product.items.some(item => item.name === 'milk'));

然后检查find是否找到了东西（不是null！）并得到它的.id，结果应该是03。或者，您可以 filter 为包含牛奶作为商品的产品，然后将所有结果映射到它们的 id：

products.filter(product =>
  product.items.some(item => item.name === 'milk');
).map(product =>
  product.id
) // [03]