Javascript-对数组进行深度过滤

出于某种原因，我有一个对象看起来像这样：

const obj = [{
    slug: 'something',
    nestedSlug: [{
      slug: 'n1',
      deeplyNestedSlug: [{
          slug: 'n11'
        },
        {
          slug: 'n21'
        }
      ]
    }]
  },
  {
    slug: 'nothing',
    nestedSlug: [{
      slug: 'n2',
      deeplyNestedSlug: [{
          slug: 'n12'
        },
        {
          slug: 'n22'
        }
      ]
    }]
  },
  {
    slug: 'anything',
    nestedSlug: [{
      slug: 'n3',
      deeplyNestedSlug: [{
          slug: 'n13'
        },
        {
          slug: 'n23'
        }
      ]
    }]
  }
]

我想要这样的结果：

['n1'，n22'，n3']

。我尝试了以下方法：

const requireItems=['n1'，n22'，n3']
让集合=[]
常量对象=[{
鼻涕虫：“某物”，
嵌套段塞：[{
鼻涕虫：“n1”，
deeplyNestedSlug：[{
鼻涕虫：“n11”
},
{
鼻涕虫：“n21”
}
]
}]
},
{
鼻涕虫：“没什么”，
嵌套段塞：[{
鼻涕虫：“n2”，
deeplyNestedSlug：[{
鼻涕虫：“n12”
},
{
鼻涕虫：“n22”
}
]
}]
},
{
鼻涕虫：“任何东西”，
嵌套段塞：[{
鼻涕虫：“n3”，
deeplyNestedSlug：[{
鼻涕虫：“n13”
},
{
鼻涕虫：“n23”
}
]
}]
}
]
让家长索引，
儿童索引
requireItems.map（x=>{
const祖父母=obj.nestedSlug.findIndex（（y，i）=>{
如果（y.slug==x）{
parentIndex=i
返回真值
}否则{
返回错误
}
})
如果（祖父母！=-1）{
collection.push（obj.nestedSlug[parentIndex]）
}否则{
const children=obj.nestedSlug[i].deeplyNestedSlug.findIndex（（z，i）=>{
如果（z.slug==x）{
childIndex=i
返回真值
}否则{
返回错误
}
})
如果（儿童！==-1）{
collection.push（obj.nestedSlug[parentIndex].deeplyNestedSlug[childIndex]）
}
}
})
console.log（集合）

const obj=[{“slug”：“something”，“nestedSlug”：[{“slug”：“n1”，“deeplyNestedSlug”：[{“slug”：“n11”}，{“slug”：“n21”}]，{“slug”：“nothing”，“nestedSlug”：“n2”，“deeplyNestedSlug”：[{“slug”：“n12”}]}，{“slug”：“n22”}]}，{“slug”：“任何东西”，“nestedSlug”：“{“slug”：“n3”，“deeplyNestedSlug”{；
var结果=[]；
用于（obj的数据）{
用于（数据的信息.nestedSlug）{
如果（信息段塞==“n2”）{
结果.push（info.deeplyNestedSlug[1].slug）；
继续；
} 
结果推送（信息段塞）
}
}
console.log（result）

我建议对嵌套数组使用相同的名称，如

nested

，以便于访问，因为这个属性是预先知道的

然后，您可以在外部级别迭代对象数组，并对照对象检查给定的

slug

。如果相等，则将对象指定给

result

变量，否则尝试从

nested

获取对象

在内部，reuslt作为短路的返回值

最后，返回找到的结果

函数getObject（数组，slug）{ var结果； array.some（o=>result=o.slug==slug&&o | | | getObject（o.nested | | |[]，slug））； 返回结果； } 变量slugs=['n1'，'n22'，'n3']， 数据=[{slug:'something'，嵌套：[{slug:'n1'，嵌套：[{slug:'n11'}，{slug:'n21'}]}，{slug:'n21'}]}，{slug:'n2'，嵌套：[{slug:'n2'，嵌套：[{slug:'n12'}，{slug:'n22'}]}，{slug:'anything'，嵌套：[{slug:'n3'，n13'}，{slug:'n23'}]}]， collection=slugs.map（getObject.bind（null，data））； 控制台日志（收集）

---

。作为控制台包装{max height:100%！important；top:0；}

你确定你不想要

[“n1”、“n2”、“n3”]

？@LucaKiebel我想要

[“n1”、“n22”、“n3”]

，我敢肯定你能解释一下它是如何工作的吗？你是如何选择什么时候在deeplyNestedSlug里面挑选的？@ChrisLi这只是随机的。这就是这个问题的妙处。说真的，顺便说一句！请对嵌套数组使用相同的名称。使用相同的命名属性搜索更深的项目更容易。但这就是您得到的，一个

obj.nestedSlug.slug

数组实际上，我只想要

['n1'，n22'，n3']

。这就是为什么我在问题中写了“深度过滤”这是一个令人讨厌的问题，鸣人昆！只是我不想要同样的结果。用户将动态输入，我将输出结果。你的是具体的，所以我很抱歉，伙计，我不会接受这个答案。那么解释一下你的对象结构会发生什么变化