Javascript 查找数组数组中最长数组的索引

如果有一个数组包含不确定数量的数组

例：

查找masterArray中最长数组的索引的有效方法是什么？（在本例中，索引为2）。

masterArray.reduce（函数（a、i、ii）{
如果（ii==1）{
归还
};
如果（i.长度>a.长度）{
返回i
}
归还
})

您可以使用

for

循环遍历外部数组的所有条目，并将每个条目的长度与迄今为止找到的最长数组进行比较

以下函数返回最长数组的索引，如果数组为空，则返回

-1

函数indexOfLongest（数组）{
var最长=-1；
对于（var i=0；iarrays[longest].length）{
最长=i；
}
}
返回时间最长；
}  
var masterArray=[[1,2,3,4,5]，
[1,2], 
[1,1,1,1,2,2,2,2,4,4],
[1,2,3,4,5] ];
document.write（indexOfLongest（masterArray））一个衬里是：

masterArray
  .map(a=>a.length)
  .indexOf(Math.max(...masterArray.map(a=>a.length)));

但是最好缓存
masterArray.map（a=>a.length）
结果

const lengths = masterArray.map(a=>a.length);
lengths.indexOf(Math.max(...lengths));

注意，此代码仍然至少对数组进行*3次迭代（
map
，
max
，
indexOf
）

*扩展运算符用于可读性，可以省略


为了提高效率，您应该手动迭代数组

let max = -Infinity;
let index = -1;
masterArray.forEach(function(a, i){
  if (a.length > max) {
    max = a.length;
    index = i;
  }
});


Reduce
方法：

masterArray.reduce((maxI,el,i,arr) => 
    (el.length>arr[maxI].length) ? i : maxI, 0);

尝试在循环时使用


var主数组=[
[1, 2, 3, 4, 5],
[1, 2],
[1, 1, 1, 1, 2, 2, 2, 2, 4, 4],
[1, 2, 3, 4, 5]
];
var i=0，len=masterArray.length；
而（我
使用lodash：

_.max(_.map(masterArray, function(v, k) { return { id: k, size: v.length }; }),'size').id;

这将创建一个具有“id”和“size”对象的新数组，然后在该数组中查找最大大小，并返回其“id”

jsfiddle：
。reduce
是最好的方法：

masterArray.reduce(function (pending, cur, index, ar) { ar[ pending ].length > cur.length ? pending : index }, 0);

或使用ES6：

masterArray.reduce((p, c, i, a) => a[p].length > c.length ? p : i, 0);

按长度按降序对索引列表排序，并取第一个：

a.map((e, i) => i) . sort((i, j) => a[j].length - a[i].length) [0]

减速器迭代数组，其中累加器表示最长数组的索引，从index
0
开始

对于每次迭代，将当前项的（数组）
长度
与当前找到的最长数组（
数组[acc]
）的
长度
进行比较，如果大于，则累加器设置为该
索引


var数组=[
[1,1,1,1,1],
[1,1], 
[1,1,1,1,1,1,1,1],   // ⬅ 最长，位于索引2处
[1,1,1,1],
[1,1,1,1,1,1]
]
var indexOfLongestArray=数组。减少（（acc、arr、idx）=>{
log（acc、idx、JSON.stringify（[arr、arrays[acc]]））
返回arr.length>arrays[acc]。长度？idx:acc
}, 0)
//打印结果：
console.log（“最长的数组位于索引：”，indexoflongestaray）
这返回最长的数组，而不是它的索引。以什么方式有效？我应该更清楚这一点。我只是简单地说，与内存效率无关。如果有多个最大长度的数组，您预计会发生什么？我更喜欢@Downgoat的解决方案。条件是
a[p].length>c.length？p:我
这是我见过的关于这个问题的最优雅的答案。是的，这是一个更好的答案。甚至可以放弃直接引用的索引用法<代码>收集。减少（（a，b）=>（a.长度>b.长度？a:b），[]）
这很好，但是如果您的一个数组是空的
idx+1
看起来太可疑，它就不起作用了。不可能是正确的=）@vp_arth-yep:）我不记得我为什么这样写，但我在你的评论后重新写了答案。谢谢你让我知道！
a.map((e, i) => i) . sort((i, j) => a[j].length - a[i].length) [0]