Javascript 在数组数组中查找对象并返回它所属的数组

我有以下数组结构：

const array = [array1, array2, array3];

三个数组中的每一个都由以下形式的对象组成：

array1 = [{x: 0, y: 1}, {x: 5, y: 9}, {x: 1, y: 8}, {x: 3, y: 2}, etc]

我试图找到最有效的方法来遍历数组数组并返回特定（唯一）对象所属的数组。例如，我有一个对象

{x:9，y:5}

它可以在array2中唯一找到，所以我想返回array2

以下是我尝试过的：

const array = [array1, array2, array3];
for (let x = 0; x < array.length; x++) {
  for (let y = 0; y < array[x].length; y++) {
    array[x].find(e => e === array[x][y])
    return array[x];
  }
}

const数组=[array1，array2，array3]；
for（设x=0；xe===数组[x][y]）
返回数组[x]；
}
}

您需要两个循环，但您可以使用一些方法来进行迭代：

let array1=[{x:0，y:1}，{x:5，y:9}，{x:1，y:8}，{x:3，y:2}]；
设array2=[{x:5，y:4}，{x:4，y:5}，{x:8，y:8}，{x:3，y:2}]；
设array3=[{x:4，y:3}，{x:0，y:6}，{x:7，y:8}，{x:5，y:2}]；
常量数组=[array1，array2，array3]；
设obj=array2[2]；//让我们找到这个。。。
让result=array.find（arr=>arr.includes（obj））；
控制台日志（结果）此处使用
查找


数据=[
[{x:1，y:2}，{x:2，y:3}]，
[{x:3，y:2}，{x:4，y:3}]，
[{x:5，y:2}，{x:6，y:3}]，
[{x:7，y:2}，{x:8，y:3}]
];
constgetarray=（{x，y}）=>data.find（a=>a.some（o=>o.x==x&&o.y==y））；
log（getArray（{x:3，y:2}））TLDR；这方面有一个有效的例子

这可以通过以下三件事来实现：


用于检查对象相等性的库，如
lodash
）


原因是直接比较两个对象的行为与您可能认为的不同

array.findIndex
查找外部数组（）的索引

array.find
查找内部数组（）中的元素

下面的方法
findobjectnnestedarray
将执行您想要的操作

const findObjectArray=（obj，arr）=>{
索引=arr.findIndex（a=>a.find（e=>e.isEqual（e，obj）））
return arr[index]//如果找不到，将返回'undefined'
}
//下面是示例代码
常量数组1=[{x:0，y:1}，{x:5，y:9}，{x:1，y:8}，{x:3，y:2}]；
常量数组2=[{x:1，y:1}，{x:2，y:2}，{x:3，y:3}，{x:4，y:4}，{x:9，y:5}]；
常量数组3=[{x:5，y:5}]；
常量数组=[array1，array2，array3]；
常量inaray2={x:9，y:5}；
常量notinaryarray={x:0，y:0}；
log（'array2'，findObjectArray（inaray2，arrays））；
log（'notin-array'，findObjectArray（notinaryarray，arrays））；
我知道我以前说过一次迭代是不可能的，但我设计了一种可能的方法，可以在特定情况下工作。本质上，您可以对属性进行排序，然后对对象进行字符串化以进行即时查找。排序是必要的，以确保始终获得一致的字符串化输出，而不管对象的属性先前存在的顺序如何。此方法有三个注意事项：

对象不能包含函数。带有函数的属性在字符串化过程中被删除

NaN和infinity被转换为null，这可能导致缓存中出现意外的“匹配”

如果对象的深度未知（即，目标对象可以包含对数组和其他对象的引用），则需要在串化之前深入遍历每个级别

这是一个折衷方案，只有在比较深度嵌套或超大对象时才能提高性能。不过，我想它是可伸缩的。。下面是一个如何实现的示例：

//对数组的值进行排序，使用递归处理子数组和对象
const sortArr=arr=>arr.sort（）.map（el=>typeof el==='object'？（Array.isArray（el）？sortArr（el）：sortObj（el））：el）
//对键的对象进行排序，然后以一致的顺序重新创建对象
const sortObj=obj=>Object.keys（obj.sort（）.reduce（（final，prop）=>{
最后[道具]=(
//如果它是一个对象，我们需要对它进行排序。。。
对象的类型[prop]=“对象”
? (
Array.isArray（对象[prop]）
？sortArr（obj[prop]）//JSON.stringify（sortObj（el）））
//从这些字符串中，创建一个对象，将字符串作为值，并关联一个“true”布尔值
const obejctCache=（obj）=>deepSortObjectArray（obj）.reduce（（acc，el）=>（{[el]：true，…acc}），{}）
//为阵列中的每个对象创建对象字符串缓存：
const cacheObjectArrays=arr=>arr.map（obj=>obejctCache（obj））
//在每个缓存中执行O（1）查找以查找匹配值：
常量findArrayContainer=（对象，缓存）=>{
const stringLookupObj=JSON.stringify（sortObj（obj））
返回caches.findIndex（cache=>cache[stringLookupObj]）
}
常量数组=[
{y:1，x:0}，
{x:5，y:9}，
{x:1，y:8}，
{x:3，y:{z:3，x:1，y:2}
]
常数arrayArray=[]，[]，数组]
常量CacheSarray=cacheObjectArrays（arrayArray）
console.log（cachesarray）
/*输出：[
{}, 
{}, 
{{“x”：3，y:{“x”：1，y:2，z:3}}：真，{“x”：1，y:8}：真，{“x”：5，y:9}：真，{“x”：0，y:1}：真}
]
*/
log（findArrayContainer（{y:1，x:0}，cachesArrays））
//输出：2；工作正常！
log（findArrayContainer（{x:0，y:1}，cachesarray））
//输出：2；不分顺序工作！
log（findArrayContainer（{y:1，x:0，q:0}，cachesarray））
//输出：-1；按预期处理未找到的对象！

正如你所看到的，这相当复杂。除非你100%的了解这实际上是性能瓶颈，否则这些性能提升可能不会转化为使交互更加顺畅

如果您对此有任何疑问，请告诉我！
我认为“排序通过”这一措辞有误导性。无论如何，两个for循环有什么问题，到目前为止您尝试了什么？两个循环一个嵌套在另一个中是100%必要的。它不必是for循环，但您需要两个迭代循环