在 JavaScript 中遍历数组的最快方法是什么？

Question

我从书上了解到你应该这样写for循环：

for(var i=0, len=arr.length; i < len; i++){
    // blah blah
}

所以不会每次都计算arr.length 。

还有人说编译器会对此做一些优化，所以你可以这样写：

for(var i=0; i < arr.length; i++){
    // blah blah
}

我只想知道实践中最好的方法是什么？

Answer 1

使用大多数现代浏览器执行此测试后： https : //jsben.ch/wY5fo

目前，最快的循环形式（在我看来是最明显的句法）。

具有长度缓存的标准 for 循环

    var i = 0, len = myArray.length;
    while (i < len) {
        // your code
        i++
    }

我想说，这绝对是我为 JavaScript 引擎开发人员鼓掌的一个案例。 运行时应该为了清晰而不是聪明而优化。

Answer 2

循环遍历 javascript 数组的绝对最快方法是：

var len = arr.length;
while (len--) {
    // blah blah
}

有关完整比较，请参阅此帖子

Answer 3

截至 2016 年 6 月，在最新的 Chrome 中进行了一些测试（2016 年 5 月浏览器市场的 71%，并且还在增加）：

最快的循环是 for 循环，无论有没有缓存长度都提供非常相似的性能。（具有缓存长度的 for 循环有时比没有缓存的 for 循环提供更好的结果，但差异几乎可以忽略不计，这意味着引擎可能已经进行了优化以支持标准并且可能是最直接的没有缓存的 for 循环）。
带有递减的 while 循环比 for 循环慢大约 1.5 倍。
使用回调函数（如标准 forEach）的循环比 for 循环慢大约 10 倍。

我认为这个线程太旧了，它误导程序员认为他们需要缓存长度，或者使用带有递减的反向遍历 whiles 来获得更好的性能，编写比简单直接的 for 循环更易读且更容易出错的代码。 因此，我建议：

如果您的应用程序迭代大量项目，或者您的循环代码位于经常使用的函数中，那么简单的 for 循环就是答案：
```
 for (var i = 0; i < arr.length; i++) { // Do stuff with arr[i] or i }
```
如果您的应用程序并没有真正迭代大量项目，或者您只需要在这里和那里进行小的迭代，那么使用标准的 forEach 回调或您选择的 JS 库中的任何类似函数可能更容易理解并且更不容易出错，因为index 变量作用域是关闭的，不需要使用方括号，直接访问数组值：
```
 arr.forEach(function(value, index) { // Do stuff with value or index });
```
如果您确实需要在迭代数十亿行时花费几毫秒，并且数组的长度在整个过程中不会改变，则可以考虑在 for 循环中缓存长度。 虽然我认为这在今天真的没有必要：
```
 for (var i = 0, len = arr.length; i < len; i++) { // Do stuff with arr[i] }
```

Answer 4

现在是 2018 年，所以更新可能会很好......

我真的不得不不同意接受的答案。 它在不同的浏览器上有所延迟。 一些forEach更快，一些for-loop ，还有一些while这里是所有方法的基准http://jsben.ch/mW36e

arr.forEach( a => {
  // ...
}

并且由于您可以看到很多 for 循环，例如for(a = 0; ... )那么值得一提的是，如果没有 'var' 变量将被全局定义，这会极大地影响速度，因此它会变慢。

Duff 的设备在 opera 上运行得更快，但在 Firefox 中则不然

 var arr = arr = new Array(11111111).fill(255); var benches = [ [ "empty", () => { for(var a = 0, l = arr.length; a < l; a++); }] , ["for-loop", () => { for(var a = 0, l = arr.length; a < l; ++a) var b = arr[a] + 1; }] , ["for-loop++", () => { for(var a = 0, l = arr.length; a < l; a++) var b = arr[a] + 1; }] , ["for-loop - arr.length", () => { for(var a = 0; a < arr.length; ++a ) var b = arr[a] + 1; }] , ["reverse for-loop", () => { for(var a = arr.length - 1; a >= 0; --a ) var b = arr[a] + 1; }] ,["while-loop", () => { var a = 0, l = arr.length; while( a < l ) { var b = arr[a] + 1; ++a; } }] , ["reverse-do-while-loop", () => { var a = arr.length - 1; // CAREFUL do { var b = arr[a] + 1; } while(a--); }] , ["forEach", () => { arr.forEach( a => { var b = a + 1; }); }] , ["for const..in (only 3.3%)", () => { var ar = arr.slice(0,arr.length/33); for( const a in ar ) { var b = a + 1; } }] , ["for let..in (only 3.3%)", () => { var ar = arr.slice(0,arr.length/33); for( let a in ar ) { var b = a + 1; } }] , ["for var..in (only 3.3%)", () => { var ar = arr.slice(0,arr.length/33); for( var a in ar ) { var b = a + 1; } }] , ["Duff's device", () => { var len = arr.length; var i, n = len % 8 - 1; if (n > 0) { do { var b = arr[len-n] + 1; } while (--n); // n must be greater than 0 here } n = (len * 0.125) ^ 0; if (n > 0) { do { i = --n <<3; var b = arr[i] + 1; var c = arr[i+1] + 1; var d = arr[i+2] + 1; var e = arr[i+3] + 1; var f = arr[i+4] + 1; var g = arr[i+5] + 1; var h = arr[i+6] + 1; var k = arr[i+7] + 1; } while (n); // n must be greater than 0 here also } }]]; function bench(title, f) { var t0 = performance.now(); var res = f(); return performance.now() - t0; // console.log(`${title} took ${t1-t0} msec`); } var globalVarTime = bench( "for-loop without 'var'", () => { // Here if you forget to put 'var' so variables'll be global for(a = 0, l = arr.length; a < l; ++a) var b = arr[a] + 1; }); var times = benches.map( function(a) { arr = new Array(11111111).fill(255); return [a[0], bench(...a)] }).sort( (a,b) => a[1]-b[1] ); var max = times[times.length-1][1]; times = times.map( a => {a[2] = (a[1]/max)*100; return a; } ); var template = (title, time, n) => `<div>` + `<span>${title} &nbsp;</span>` + `<span style="width:${3+n/2}%">&nbsp;${Number(time.toFixed(3))}msec</span>` + `</div>`; var strRes = times.map( t => template(...t) ).join("\\n") + `<br><br>for-loop without 'var' ${globalVarTime} msec.`; var $container = document.getElementById("container"); $container.innerHTML = strRes;

 body { color:#fff; background:#333; font-family:helvetica; } body > div > div { clear:both } body > div > div > span { float:left; width:43%; margin:3px 0; text-align:right; } body > div > div > span:nth-child(2) { text-align:left; background:darkorange; animation:showup .37s .111s; -webkit-animation:showup .37s .111s; } @keyframes showup { from { width:0; } } @-webkit-keyframes showup { from { width:0; } }

 <div id="container"> </div>

Answer 5

如果顺序不重要，我更喜欢这种风格：

for(var i = array.length; i--; )

它缓存长度并且写入要短得多。 但它会以相反的顺序遍历数组。

Answer 6

2014 While是背

只是想合乎逻辑。

看这个

for( var index = 0 , length = array.length ; index < length ; index++ ) {

 //do stuff

}

需要创建至少 2 个变量（索引、长度）
需要检查索引是否小于长度
需要增加索引
for循环有3个参数

现在告诉我为什么这应该比：

var length = array.length;

while( --length ) { //or length--

 //do stuff

}

一变量
没有检查
指数下降（机器更喜欢）
while只有一个参数

当 Chrome 28 显示 for 循环比 while 更快时，我完全感到困惑。 这一定是某种

“呃，每个人都在使用 for 循环，让我们在为 chrome 开发时专注于它。”

但是现在，在 2014 年，while 循环又回到了 chrome 上。 它快 2 倍，在其他/旧浏览器上它总是更快。

最近我做了一些新的测试。 现在在现实世界环境中，这些短代码一文不值，jsperf 实际上无法正确执行 while 循环，因为它需要重新创建 array.length，这也需要时间。

您无法在 jsperf 上获得 while 循环的实际速度。

您需要创建自己的自定义函数并使用window.performance.now()检查

是的...... while 循环不可能更快。

真正的问题实际上是 dom 操作/渲染时间/绘图时间，或者你想怎么称呼它。

例如，我有一个画布场景，我需要在其中计算坐标和碰撞……这是在 10-200 微秒（不是毫秒）之间完成的。 它实际上需要不同的毫秒来渲染所有内容。与 DOM 中的相同。

但

在某些情况下，还有另一种使用 for loop超高性能方法......例如复制/克隆数组

for(
 var i = array.length ;
 i > 0 ;
 arrayCopy[ --i ] = array[ i ] // doing stuff
);

注意参数的设置：

和 while 循环一样，我只使用一个变量
需要检查索引是否大于0；
正如您所看到的，这种方法与每个人都使用的普通 for 循环不同，因为我在第 3 个参数内执行操作，并且我也直接在数组内减少。

说到这里，这证实了像这样的机器——

写我想把它缩短一点并删除一些无用的东西并使用相同的风格写这个：

for(
 var i = array.length ;
 i-- ;
 arrayCopy[ i ] = array[ i ] // doing stuff
);

即使它更短，看起来像使用i多一次会减慢一切。 它比前一个for循环和while循环慢 1/5。

注意： ; 在没有{}的 for looo 之后非常重要

即使我只是告诉你 jsperf 不是测试脚本的最佳方式......我在这里添加了这 2 个循环

http://jsperf.com/caching-array-length/40

这是关于 javascript 性能的另一个答案

https://stackoverflow.com/a/21353032/2450730

这个答案是为了展示编写 javascript 的高效方法。 因此，如果您看不懂，请询问，您会得到答案或阅读有关 javascript 的书http://www.ecma-international.org/ecma-262/5.1/

Answer 7

http://jsperf.com/caching-array-length/60

我准备的最新版本的测试（通过重用旧版本）显示了一件事。

缓存长度不是那么重要，但它没有坏处。

上面链接的测试的每次第一次运行（在新打开的选项卡上）在我的 Debian Squeeze 64 位（我的桌面硬件）中的 Chrome、Opera 和 Firefox 中的最后 4 个片段（图表中的第 3、5、7 和 10）的最佳结果）。 随后的运行给出了完全不同的结果。

性能方面的结论很简单：

使用 for 循环（向前）并使用!==而不是<测试。
如果您以后不必重用数组，那么 while 循环减少长度和破坏性shift() -ing 数组也是有效的。

tl;博士

现在（2011.10）下面的模式看起来是最快的。

for (var i = 0, len = arr.length; i !== len; i++) {
    ...
}

请注意，缓存arr.length在这里并不重要，因此您可以只测试i !== arr.length并且性能不会下降，但您会得到更短的代码。

PS：我知道在带有shift()代码段中可以使用它的结果而不是访问第 0 个元素，但是在重用以前的修订版（while 循环错误）之后，我不知何故忽略了这一点，后来我不想丢失已经获得的结果。

Answer 8

纯性能中的“最佳”？ 或性能和可读性？

纯性能“最佳”就是这样，它使用缓存和 ++prefix 运算符（我的数据： http : //jsperf.com/caching-array-length/189 ）

for (var i = 0, len = myArray.length; i < len; ++i) {
  // blah blah
}

我认为无缓存 for 循环是执行时间和程序员阅读时间的最佳平衡。 每个从 C/C++/Java 开始的程序员都不会浪费一毫秒来阅读这个

for(var i=0; i < arr.length; i++){
  // blah blah
}

Answer 9

**在循环内缓存数组长度，将避免几秒钟的时间。取决于数组中的项目，如果数组中有更多项目，则时间女士有很大差异*

**

sArr; //Array[158];

for(var i = 0 ; i <sArr.length ; i++) {
 callArray(sArr[i]); //function call
}

***end: 6.875ms***

**

sArr; //Array[158];
for(var i = 0,len = sArr.length ; i < len ; i++) {
  callArray(sArr[i]); //function call
}

***end: 1.354ms***

**

Answer 10

这看起来是迄今为止最快的方式......

var el;
while (el = arr.shift()) {
  el *= 2;
}

考虑到这将消耗阵列，吃掉它，并且什么都不留下......

Answer 11

这是2017 年。

我做了一些测试。

https://jsperf.com/fastest-way-to-iterate-through-an-array/

看起来while方法在 Chrome 上是最快的。

看起来左边的减量（ --i ）比其他（ ++i 、 i-- 、 i++ ）在 Firefox 上快得多。

这种方法是平均禁食。 但它以相反的顺序迭代数组。

let i = array.length;
while (--i >= 0) {
    doSomething(array[i]);
}

如果前向顺序很重要，请使用此方法。

let ii = array.length;
let i = 0;
while (i < ii) {
    doSomething(array[i]);
    ++i;
}

Answer 12

我总是以第一种风格写作。

即使编译器足够聪明，可以针对数组对其进行优化，但是如果我们在这里使用 DOMNodeList 或一些具有计算长度的复杂对象，它仍然很聪明吗？

我知道关于数组的问题是什么，但我认为以一种风格编写所有循环是一种很好的做法。

Answer 13

var arr = []; // The array
var i = 0;
while (i < arr.length) {
    // Do something with arr[i]
    i++;
}

i++ 比 ++i、--i 和 i-- 快

此外，您可以在最后一次需要访问 i 时保存执行 arr[i++] 的最后一行（但这可能很难调试）。

您可以在此处进行测试（使用其他循环测试）： http : //jsperf.com/for-vs-whilepop/5

Answer 14

截至 2017 年 9 月，这些 jsperf 测试显示以下模式在 Chrome 60 上性能最佳：

function foo(x) {
 x;
};
arr.forEach(foo);

有人可以繁殖吗？

Answer 15

如果您想要更快的for循环，请在循环外定义变量并使用以下语法

  const iMax = lengthOftheLoop;
  var i = 0;
  for (; i < iMax; i++) {
    console.log("loop"+i);
  }

参考： https : //medium.com/kbdev/voyage-to-the-most-efficient-loop-in-nodejs-and-a-bit-js-5961d4524c2e

Answer 16

我一直在这里进行测试。 检查此https://gist.github.com/DungGramer/7efdfefecaa1b8f5d6510202524dc751

我的结果：

pop是最快的， forEach是最好的可读性和快速
做do..while比for快
如果没有条件，则循环更快（例如if ）
--i最快

Answer 17

我尝试了一些其他方法来迭代一个巨大的数组，发现将数组长度减半，然后在一个循环中迭代两半会更快。 在处理巨大的数组时可以看到这种性能差异。

var firstHalfLen =0;
var secondHalfLen = 0;
var count2=0;
var searchterm = "face";
var halfLen = arrayLength/2;
if(arrayLength%2==halfLen)
{
   firstHalfLen = Math.ceil(halfLen);
   secondHalfLen=Math.floor(halfLen);
}
else
{
   firstHalfLen=halfLen;
   secondHalfLen=halfLen;
}
for(var firstHalfCOunter=0,secondHalfCounter = arrayLength-secondHalfLen;
    firstHalfCOunter < firstHalfLen;
    firstHalfCOunter++)
{
  if(mainArray[firstHalfCOunter].search(new RegExp(searchterm, "i"))> -1)
  {
    count2+=1;
  }
  if(secondHalfCounter < arrayLength)
  {
    if(mainArray[secondHalfCounter].search(new RegExp(searchterm, "i"))> -1)
    {
        count2+=1;
    }
    secondHalfCounter++; 
  }
}

缓存长度 for-loop 与上述方法之间的一些性能比较（使用 timer.js）。

http://jsfiddle.net/tejzpr/bbLgzxgo/

Answer 18

另一个 jsperf.com 测试： http ://jsperf.com/while-reverse-vs-for-cached-length

反向 while 循环似乎是最快的。 唯一的问题是 while (--i) 将在 0 处停止。那么我如何在循环中访问 array[0] 呢？

Answer 19

基本的 while 循环通常是最快的。 jsperf.com 是一个很好的沙箱来测试这些类型的概念。

https://jsperf.com/fastest-array-loops-in-javascript/24

Answer 20

While 循环比 for 循环快一点。

var len = arr.length;
while (len--) {
    // blah blah
}

使用 for 循环代替

Answer 21

您可以使用递归来模拟循环：

function loop (repeats, callback) {
    if (repeats > 0) {
        callback(repeats);
        loop(repeats-1, callback);
    }
}
loop(5, function(e){
    console.log(e);
    //blah blah blah
});
/**
 * 5
 * 4
 * 3
 * 2
 * 1
 */

优点是：

）））-无需声明和跟踪变量名等
）））-避免栅栏错误（一次错误）

缺点：

）））-影响堆叠

Answer 22

最快的方法是传统的 for 循环。 这是一个更全面的性能比较。

https://gists.cwidanage.com/2019/11/how-to-iterate-over-javascript-arrays.html

Answer 23

我尝试使用performance.now（）分析不同类型的循环的性能。 我采用了一个非常大的数组，并找到了数组所有元素的总和。 我跑的代码，每次三次，发现的forEach和减少是一个明显的赢家。

// For循环

let arr = [...Array(100000).keys()]
function addUsingForLoop(ar){
  let sum = 0;
  for(let i = 0; i < ar.length; i++){
    sum += ar[i];
  }
   console.log(`Sum: ${sum}`);
   return sum;
}
let t1 = performance.now();
addUsingForLoop(arr);
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 42.17500000959262 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 44.41999999107793 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 49.845000030472875 milliseconds"

// While循环

let arr = [...Array(100000).keys()]
function addUsingWhileLoop(ar){
let sum = 0;
let index = 0;
while (index < ar.length) {
  sum += ar[index];
  index++;
}
  console.log(`Sum: ${sum}`)
  return sum;
}
let t1 = performance.now();
addUsingWhileLoop(arr);
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 44.2499999771826 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 44.01999997207895 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 41.71000001952052 milliseconds"

//做

let arr = [...Array(100000).keys()]
function addUsingDoWhileLoop(ar){
let sum = 0;
let index = 0;
do {
   sum += index;
   index++;
} while (index < ar.length);
   console.log(`Sum: ${sum}`);
   return sum;
}
let t1 = performance.now();
addUsingDoWhileLoop(arr);
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 43.79500000504777 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 43.47500001313165 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 47.535000019706786 milliseconds"

//反向循环

let arr = [...Array(100000).keys()]
function addUsingReverseLoop(ar){
   var sum=0;
   for (var i=ar.length; i--;) {
     sum+=arr[i];
   }
   console.log(`Sum: ${sum}`);
   return sum;
}
let t1 = performance.now();
addUsingReverseLoop(arr);
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 46.199999982491136 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 44.96500000823289 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 43.880000011995435 milliseconds"

//反转while循环

let arr = [...Array(100000).keys()]
function addUsingReverseWhileLoop(ar){
    var sum = 0;
    var i = ar.length; 
    while (i--) {
        sum += ar[i];
    }
    console.log(`Sum: ${sum}`);
    return sum;
}
var t1 = performance.now();
addUsingReverseWhileLoop(arr);
var t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 46.26999999163672 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 42.97000000951812 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 44.31500000646338 milliseconds"

// 降低

let arr = [...Array(100000).keys()]
let t1 = performance.now();
sum = arr.reduce((pv, cv) => pv + cv, 0);
console.log(`Sum: ${sum}`)
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 4.654999997001141 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 5.040000018198043 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 4.835000028833747 milliseconds"

// forEach

let arr = [...Array(100000).keys()]
function addUsingForEach(ar){
  let sum = 0;
  ar.forEach(item => {
    sum += item;
  })
    console.log(`Sum: ${sum}`);
    return sum
}
let t1 = performance.now();
addUsingForEach(arr)
let t2 = performance.now();
console.log(`Time Taken ~ ${(t2 - t1)} milliseconds`)

// "Sum: 4999950000"
// "Time Taken ~ 5.315000016707927 milliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 5.869999993592501 mienter code herelliseconds"
// "Sum: 4999950000"
// "Time Taken ~ 5.405000003520399 milliseconds"

Answer 24

虽然这是一个很老的问题，但这是一个非常有趣的问题，

请原谅我稍微调整了这个问题，但我会在最后回答它。

这个问题让我问自己是否有更好的 js 循环方法：

所以我做了一些测试，这是我发现的：

对于 1000_000 记录：最好的是 forEach。

对于 100 条记录：这无关紧要。

回到你的问题：

我创建的示例与问题不完全相同……但我发现了一些有趣的事情：

首先：就像你说的那样， arr.length 每次都会评估它是否在比较语句 i < arr.length ...

注意：下面的 arrLength 变量不超过 1000_000 条记录。

例如：这行不通

但这会

它将需要 0.036 秒 .. 与如果数字恒定所需的时间相比，这是非常大的......

总结，

最好使用 FOREACH

在您的情况下： i<arr.length 应该花费更多时间（通常约为 1.3）

查看测试：查看测试

Answer 25

for(var i=0; i < arr.length; i++){ // blah blah }

Answer 26

Benchmarking [10000000] element array...
The fastest [for ++] took [76762166ns]
┌─────────┬───────────────────────┬────────────┬──────────┐
│ (index) │         type          │  time[ns]  │ baseline │
├─────────┼───────────────────────┼────────────┼──────────┤
│    0    │       'for ++'        │  76762166  │    1     │
│    1    │       'for of'        │  82407583  │   1.07   │
│    2    │   '--while forward'   │  83723083  │   1.09   │
│    3    │ 'do while forward --' │  83942958  │   1.09   │
│    4    │ '--do while forward'  │  84225584  │   1.1    │
│    5    │  'while forward --'   │  85156957  │   1.11   │
│    6    │    '--while >= 0'     │  89745916  │   1.17   │
│    7    │     '++ do while'     │  90306542  │   1.18   │
│    8    │     'for !== ++'      │  90319083  │   1.18   │
│    9    │       '-- for'        │  90360167  │   1.18   │
│   10    │   'for i length --'   │  90558833  │   1.18   │
│   11    │       '++ for'        │  90616125  │   1.18   │
│   12    │     'do while ++'     │  90657541  │   1.18   │
│   13    │   '--for i length'    │  90757708  │   1.18   │
│   14    │       'for --'        │  90799875  │   1.18   │
│   15    │      '++ while'       │  92697417  │   1.21   │
│   16    │     '++ for !=='      │  94488209  │   1.23   │
│   17    │         'pop'         │ 108399917  │   1.41   │
│   18    │      'while ++'       │ 109276500  │   1.42   │
│   19    │    'forEach call'     │ 147140124  │   1.92   │
│   20    │       'forEach'       │ 148886207  │   1.94   │
│   21    │         'map'         │ 207100583  │   2.7    │
│   22    │     'Array from'      │ 353166207  │   4.6    │
│   23    │       'flatMap'       │ 1213152082 │   15.8   │
│   24    │   'Object.keys map'   │ 1294475333 │  16.86   │
│   25    │       'for in'        │ 1338988749 │  17.44   │
└─────────┴───────────────────────┴────────────┴──────────┘

在 Macbook Air M1 2020 上测试。NodeJS 18。

对于具有10_000_000元素的 arrays，for 循环标准胜出。 对于其他情况，请参阅我的要点： https://gist.github.com/episage/076ded007d0583f6a275f93a8c9c8047#file-result-txt

向@DungGramer 大喊大叫。 我修复了错误并增强了他的基准。

Answer 27

我所知道的最优雅的解决方案是使用 map。

var arr = [1,2,3];
arr.map(function(input){console.log(input);});

Answer 28

在数组中循环的更快方法是使用过滤器。 filter（）方法创建一个新数组，其中所有元素都通过了由提供的函数实现的测试。

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

 const words = ['Floccinaucinihilipilification', 'limit', 'elite', 'Hippopotomonstrosesquipedaliophobia', 'destruction', 'present']; const result = words.filter(word => word.length > 6); console.log(new Date(), result);

根据我的经验，我总是喜欢过滤器，地图等。

Answer 29

到 2019 年 WebWorker 更加流行，对于大型数据集，我们可以通过充分利用多核处理器来使用 WebWorker 进行更快的处理。

我们还有Parallel.js ，它使 WebWorker 更易于用于数据处理。

Answer 30

试试这个：

var myarray =[],
i = myarray.lenght;
while(i--){
// do somthing
}

Answer 31

现在是 2022 年末

有时根本用数组长度计算是无效的：

如果您有一个索引为var myArray = [1,2,3,4,25,999999999999]的数组，那么使用任何通过数组索引增加一（包括forEach ）的解决方案都会非常慢。

对我来说最好的解决方案，并且在任何投票最高的答案中都没有提到是：

for(let _i in myArray ) {
   if(myArray[_i]) {
     (function(s) {
        ///
     })(myArray[_i]) 
   }
}

在 JavaScript 中遍历数组的最快方法是什么？

问题描述

26 个解决方案

解决方案1
370 已采纳 2011-08-31 03:00:28

解决方案2
94 2011-03-18 08:13:52

解决方案3
51 2016-06-18 16:05:32

解决方案4
38 2018-03-05 08:11:25

解决方案5
37 2011-03-18 08:15:04

解决方案6
20 2014-06-02 15:58:25

解决方案7
11 2011-10-17 15:47:49

解决方案8
10 2013-06-09 20:54:25

解决方案9
7 2014-11-10 19:31:33

解决方案10
6 2015-06-18 22:45:31

解决方案11
4 2017-05-22 09:28:16

解决方案12
2 2011-03-18 08:09:27

解决方案13
1 2014-07-24 16:21:15

解决方案14
1 2017-09-18 14:03:10

解决方案15
1 2020-10-06 05:18:23

解决方案16
1 2022-03-24 18:03:41

我的结果：

解决方案17
0 2014-11-08 00:10:52

解决方案18
0 2014-11-20 14:32:52

解决方案19
0 2017-11-08 17:52:38

解决方案20
0 2018-04-14 05:47:02

解决方案21
0 2019-09-11 22:57:50

解决方案22
0 2019-11-25 04:04:07

解决方案23
0 2019-11-26 14:15:10

解决方案24
0 2021-10-28 10:44:42

总结，

解决方案25
0 2022-07-24 15:40:46

解决方案26
0 2022-12-04 10:40:09

解决方案27
-1 2013-01-04 22:28:24

解决方案28
-1 2018-10-22 12:07:19

解决方案29
-1 2019-01-12 16:23:10

解决方案30
-2 2018-07-18 02:45:40

解决方案31
-2 2022-10-05 06:59:18

在 JavaScript 中遍历数组的最快方法是什么？

问题描述

26 个解决方案

解决方案1 370 已采纳 2011-08-31 03:00:28

解决方案2 94 2011-03-18 08:13:52

解决方案3 51 2016-06-18 16:05:32

解决方案4 38 2018-03-05 08:11:25

解决方案5 37 2011-03-18 08:15:04

解决方案6 20 2014-06-02 15:58:25

解决方案7 11 2011-10-17 15:47:49

解决方案8 10 2013-06-09 20:54:25

解决方案9 7 2014-11-10 19:31:33

解决方案10 6 2015-06-18 22:45:31

解决方案11 4 2017-05-22 09:28:16

解决方案12 2 2011-03-18 08:09:27

解决方案13 1 2014-07-24 16:21:15

解决方案14 1 2017-09-18 14:03:10

解决方案15 1 2020-10-06 05:18:23

解决方案16 1 2022-03-24 18:03:41

我的结果：

解决方案17 0 2014-11-08 00:10:52

解决方案18 0 2014-11-20 14:32:52

解决方案19 0 2017-11-08 17:52:38

解决方案20 0 2018-04-14 05:47:02

解决方案21 0 2019-09-11 22:57:50

解决方案22 0 2019-11-25 04:04:07

解决方案23 0 2019-11-26 14:15:10

解决方案24 0 2021-10-28 10:44:42

总结，

解决方案25 0 2022-07-24 15:40:46

解决方案26 0 2022-12-04 10:40:09

解决方案27 -1 2013-01-04 22:28:24

解决方案28 -1 2018-10-22 12:07:19

解决方案29 -1 2019-01-12 16:23:10

解决方案30 -2 2018-07-18 02:45:40

解决方案31 -2 2022-10-05 06:59:18

解决方案1
370 已采纳 2011-08-31 03:00:28

解决方案2
94 2011-03-18 08:13:52

解决方案3
51 2016-06-18 16:05:32

解决方案4
38 2018-03-05 08:11:25

解决方案5
37 2011-03-18 08:15:04

解决方案6
20 2014-06-02 15:58:25

解决方案7
11 2011-10-17 15:47:49

解决方案8
10 2013-06-09 20:54:25

解决方案9
7 2014-11-10 19:31:33

解决方案10
6 2015-06-18 22:45:31

解决方案11
4 2017-05-22 09:28:16

解决方案12
2 2011-03-18 08:09:27

解决方案13
1 2014-07-24 16:21:15

解决方案14
1 2017-09-18 14:03:10

解决方案15
1 2020-10-06 05:18:23

解决方案16
1 2022-03-24 18:03:41

解决方案17
0 2014-11-08 00:10:52

解决方案18
0 2014-11-20 14:32:52

解决方案19
0 2017-11-08 17:52:38

解决方案20
0 2018-04-14 05:47:02

解决方案21
0 2019-09-11 22:57:50

解决方案22
0 2019-11-25 04:04:07

解决方案23
0 2019-11-26 14:15:10

解决方案24
0 2021-10-28 10:44:42

解决方案25
0 2022-07-24 15:40:46

解决方案26
0 2022-12-04 10:40:09

解决方案27
-1 2013-01-04 22:28:24

解决方案28
-1 2018-10-22 12:07:19

解决方案29
-1 2019-01-12 16:23:10

解决方案30
-2 2018-07-18 02:45:40

解决方案31
-2 2022-10-05 06:59:18