**缓存数组的长度在循环内，一些秒的时间将被规避。取决于数组中的项，如果数组中有更多项，则时间毫秒有很大差异*

**

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***

**

2014年While回来了

要有逻辑性。

看看这个

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

 //do stuff

}

需要创建至少2个变量(index,length) 需要检查索引是否小于长度 需要增加索引 for循环有3个参数

现在告诉我为什么这个要比

var length = array.length;

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

 //do stuff

}

一个变量 没有检查 指数下降(机器更喜欢这样) While只有一个参数

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

“嗯，每个人都在使用for循环，让我们专注于这个 为铬开发。”

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

最近我做了一些新的测试。现在在现实环境中，这些短代码毫无价值，jsperf实际上不能正确执行while循环，因为它需要重新创建数组。长度也需要时间。

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

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

是的……while循环不可能简单地更快。

真正的问题实际上是dom操作/渲染时间 画图时间，随你怎么叫。

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

BUT

在某些情况下，还有另一种使用for循环的超级性能方式……例如复制/克隆一个数组

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

注意参数的设置:

与while循环中一样，我只使用一个变量 需要检查索引是否大于0; 正如你所看到的，这种方法与每个人都使用的正常for循环不同，因为i在第3个参数内做东西，并且i也直接在数组内减少。

说到这里，这证实了机器喜欢

我想把它写得短一点，去掉一些无用的东西，用同样的风格写了这篇文章:

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

即使它更短，但再次使用i似乎会减慢一切。 它比之前的for循环和while循环慢了1/5。

注:;在没有{}的for looo后面非常重要

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

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/

我总是用第一种体裁写作。

即使编译器足够智能，可以为数组优化它，但如果我们在这里使用DOMNodeList或一些计算长度的复杂对象，它仍然是智能的?

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

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

请原谅我稍微改变一下这个问题，但我会在最后回答这个问题。

这个问题让我问自己，在js中是否有更好的循环方法:

所以我做了一些测试，以下是我的发现:

对于1000_000记录:最好是forEach。

对于100条记录:这根本不重要。

---

回到你刚才的问题:

我创建的例子和问题不完全一样。但我发现了一些有趣的事情:

首先，就像你说的，arr。如果它在比较语句I < arr内，Length每次都会计算。长度……

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

例如:这不会工作

但是这个会

这需要0.036秒。与数字不变的情况相比，这是非常大的……

---

总之，

最好使用FOREACH

在你的例子中，i<arr。长度需要更多的时间(通常在1.3左右)

请参阅测试: 查看测试

现在是2017年。

我做了一些测试

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

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

看起来左边递减(——i)比Firefox上的其他递减(++i, i——，i++)快得多。

这种方法平均来说是最快的。但是它以相反的顺序迭代数组。

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

如果前向顺序很重要，可以使用这种方法。

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

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个元素的数组，循环标准胜出。关于其他情况，请参阅我的要点:https://gist.github.com/episage/076ded007d0583f6a275f93a8c9c8047#file-result-txt

大声喊出@DungGramer。我修复了bug并提高了他的基准测试。