Javascript 在数组中查找数组中的元素并返回带有父对象的元素

鉴于

    var a = [{ b: [{ i: 2 }, { i: 3 }] }, { b: [{ i: 4 }, { i: 5 }] }, { b: [{ i: 6 }, { i: 7 }] }];

例如，使用

i=5

加上包含该对象所在数组的对象，找到该对象的好方法是什么

因此，结果将是两个参考

var r0 = { "i": 5 };
var r1 = { "b": [{ "i": 4 }, { "i": 5 } ]};

使用箭头：

vara=[{b:[{i:2}，{i:3}]}，{b:[{i:4}，{i:5}]}，{b:[{i:6}，{i:7}]}；
var result=a.filter（x=>x.b.find（b=>b.i==5））；
console.log（结果）

您可以使用

forEach

：

vara=[{b:[{i:2}，{i:3}]}，{b:[{i:4}，{i:5}]}，{b:[{i:6}，{i:7}]}；
var r0；
var-r1；
a、 forEach（功能（项目）{
项目b.forEach（功能（内部）{
if（内部.i==5）{
r0=内部；r1=项目；
}
});
});
console.log（r0）；
控制台日志（r1）我认为解决方案可能会根据您的实际背景而有所不同，比如您考虑的最重要的因素，如时间、空间、读/写效率等

以下是两种基本用法的解决方案：


vara=[{b:[{i:2}，{i:3}]}，{b:[{i:4}，{i:5}]}，{b:[{i:6}，{i:7}]}]
//常见的方法是：它必须为每个查询循环整个数组
queryItem1=函数（searchTarget、searchVal）{
返回searchTarget.filter(
功能（val）{
return val.b.filter（函数（项）{return item.i==searchVal；}）.length>0；
}
)
}
console.log（'---通用方式--'）
console.log（查询项1（a，5））
console.log（'--end--'）
//考虑“查询”效率；
//构建一次索引，然后一步一步地查询，而不是循环查询
buildIndexes=函数（目标）{
让索引=新对象（）；
for（目标中的索引）{
对于（目标[index].b中的itemIndex）{
让queryVal=target[index].b[itemIndex].i；
让queryIndex=索引；
如果（！索引[queryVal]）{
索引[queryVal]=[]；
}
索引[queryVal].push（queryIndex）；
}
}
收益指标；
}
log（'--考虑'query`效率方式--'）
索引=构建索引（a）
//console.log（index）//显示索引树
console.log（'---测试用例1---'）
log（indexes[5]）//如果query vale为5，则获取索引，然后像[indexes[5][0]一样调用
console.log（a[索引[5][0]]
console.log（'---测试用例2---'）
log（index[6]）//如果query vale为6，则获取索引，然后像[index[6][0]一样调用
console.log（a[索引[6][0]]
console.log（'--end--'）
两次迭代都可以使用，因为如果找到，迭代将通过返回
true
停止

此建议返回第一个找到的元素，条件为
true


var数组=[{b:[{i:2}，{i:3}]}，{b:[{i:4}，{i:5}]}，{b:[{i:6}，{i:7}]}，
i=5，
r0，r1；
array.some（函数（a）{
返回a.b.some（函数（b）{
如果（b.i==i）{
r0=b；
r1=a；
返回true；
}
});
});
console.log（r0）；
控制台日志（r1）
.as console wrapper{max height:100%！important；top:0；}
也许我不够清楚，但我在引用
{I:5}
和
{b:[{I:4}，{I:5}}
。但是
foreach
在找到元素时不会短路。真的
如果真的话返回假的话，否则返回真的
？使用全局变量？并且不使用内部
每个
的返回值？