Javascript 如何使用lodash查找内部数组包含其他对象的数组中的对象

我有以下阵列：

const tasks = [
  {id: 0, name: 'a', tags: [{id: 0, name: 'q'}, {id: 7, name: 'i'}]},
  {id: 1, name: 'b', tags: [{id: 2, name: 'e'}, {id: 4, name: 't'}, {id: 2, name: 'e'}, {id: 0, name: 'q'}]},
  {id: 2, name: 'c', tags: []},
  {id: 3, name: 'd', tags: [{id: 7, name: 'i'}, {id: 3, name: 'r'}, {id: 0, name: 'q'}]},
  {id: 6, name: 'g', tags: [{id: 7, name: 'i'}, {id: 4, name: 't'}]},
]

const tags = [
  {id: 0, name: 'q'},
  {id: 1, name: 'w'},
  {id: 2, name: 'e'},
  {id: 3, name: 'r'},
  {id: 4, name: 't'},
  {id: 7, name: 'i'},
  {id: 11, name: 's'}
]

let selectedTags = [0, 5]

selectedTags

是

标记的索引数组

数组。现在我需要在

tasks

数组中查找所有对象，其中property

tags

包含所有选定的标记。因此，在这种情况下，输出应为：

let result = [
  {id: 0, name: 'a', tags: [{id: 0, name: 'q'}, {id: 7, name: 'i'}]},
  {id: 3, name: 'd', tags: [{id: 7, name: 'i'}, {id: 3, name: 'r'}, {id: 0, name: 'q'}]}
]

我试着这样做：

let result= []
_.forEach(selectedTags, index => {
  const tagId = tags[index]._id
  result = _.filter(tasks, task => _.find(task.tags, ['_id', tagId]))
})

但是

结果

数组包含的对象中

标记

数组只有一个选定的标记（总是相同的标记）

---

有什么想法吗？

首先从选定的标签中生成

名称

，并在任务上使用

过滤器

const filter=（任务、标记、选定标记）=>{
const name=selectedTags.map（tag=>tags[tag].name）；
返回任务。筛选器（任务=>
names.every（name=>task.tags.map（x=>x.name）.includes（name））
);
};
常量任务=[
{
id:0，
名称：“a”，
标签：[
{id:0，名称：“q”}，
{id:7，名字：“i”}
]
},
{
id:1，
名称：“b”，
标签：[
{id:2，名称：“e”}，
{id:4，名称：“t”}，
{id:2，名称：“e”}，
{id:0，名称：“q”}
]
},
{id:2，名称：“c”，标记：[]}，
{
id:3，
名称：“d”，
标签：[
{id:7，名字：“i”}，
{id:3，名称：“r”}，
{id:0，名称：“q”}
]
},
{
id:6，
名称：“g”，
标签：[
{id:7，名字：“i”}，
{id:4，名称：“t”}
]
}
];
常量标记=[
{id:0，名称：“q”}，
{id:1，名称：“w”}，
{id:2，名称：“e”}，
{id:3，名称：“r”}，
{id:4，名称：“t”}，
{id:7，名字：“i”}，
{id:11，名称：“s”}
];
设selectedTags=[0,5]；
日志（过滤器（任务、标签、所选标签））一种方法是将所选标记映射到等效的标记数组中

接下来使用
each
确保所选标签中的每个项目都存在于tasks.tags数组中，使用
some

下面的例子


（代码>代码>常量常量任务=JSON<代码>警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警警“}]}，{“id”：6，“name”：“g”，“标记”：[{“id”：7，“name”：“i”}，{“id”：4，“name”：“t”}]}]；
const tags=JSON.parse（'[{“id”：0，“name”：“q”}，{“id”：1，“name”：“w”}，{“id”：2，“name”：“e”}，{“id”：3，“name”：“r”}，{“id”：4，“name”：“t”}，{“id”：7，“name”：“i”}，{“id”：11，“name”：“s”}）；
设selectedTags=[0,5]；
const result=tasks.filter（f=>
selectedTags.map（m=>tags[m]）。每(
e=>f.tags.some（s=>s.id==e.id））；
console.log（result）；

可以使用

reduce

方法，并在每次迭代中检查元素是否包含所需的标记：

const tagsToFind = selectedTags.map(s => tags[s]);

const result = tasks.reduce((a, c) => {
    if (tagsToFind.every(t => c.tags.some(s => s.name == t.name)))
        a.push(c);
    return a;
},[])

例如：

const任务=[
{id:0，名称：'a'，标记：[{id:0，名称：'q'}，{id:7，名称：'i'}]}，
{id:1，名称：'b'，标记：[{id:2，名称：'e'}，{id:4，名称：'t'}，
{id:2，名称：'e'}，{id:0，名称：'q'}]}，
{id:2，名称：'c'，标记：[]}，
{id:3，名称：'d'，标记：[{id:7，名称：'i'}，{id:3，名称：'r'}，
{id:0，名称：'q'}]}，
{id:6，name'g'，标记：[{id:7，name'i'}，{id:4，name't'}]，
];
常量标记=[
{id:0，名称：'q'}，
{id:1，名称：'w'}，
{id:2，名称：'e'}，
{id:3，名称：'r'}，
{id:4，名称：'t'}，
{id:7，名称：'i'}，
{id:11，名称：'s'}
];
设selectedTags=[0,5]；
const tagsToFind=selectedTags.map（s=>tags[s]）；
常量结果=任务。减少（（a，c）=>{
if（tagsToFind.every（t=>c.tags.some（s=>s.name==t.name）））
a、 推（c）；
返回a；
},[])
console.log（result）；

它看起来类似于forEach循环中的

结果

被覆盖（这可以解释为什么它总是同一个/最后一个有效的标记）您的测试数据似乎没有您所说的结果，您选择的标记是

[0，5]

但您的预期结果不是5，而是7，这是一个输入错误吗？@Keith我相信它是

标签中索引
5
处的对象array@Ele是的，它是相似的。区别在于我需要在这里找到所有选定标记的对象，而在另一个问题中，它是任何选定的。感谢您的帮助！但是返回的对象还包括ID为1的对象，该对象的标记数组没有所有选定的标记。是的，但它没有标记“i”。啊，我的错。[0，5]没有意识到这些索引。@Igal，用fix更新了答案。非常感谢！工作完美！我只是用lodash的方式重新编写了它：
让结果=\过滤器（任务，任务=>\每个（u.map（selectedTags，i=>tags[i]），sTag=>some（task.tags，tag=>tag.id==sTag.id））