我从书中学到，你应该这样写for循环:
for(var i=0, len=arr.length; i < len; i++){
// blah blah
}
所以arr。每次不计算长度。
其他人说编译器会做一些优化，所以你可以这样写:
for(var i=0; i < arr.length; i++){
// blah blah
}
我只是想知道在实践中哪种方法是最好的?
当前回答
现在是2022年底
有时根本没有用数组长度计算:
如果你有一个索引为var myArray =[1,2,3,4,25,99999999999999]的数组，使用任何索引为1的槽数组(包括forEach)的解决方案都是非常缓慢的。
对我来说，最好的解决方案是:
for(let _i in myArray ) {
if(myArray[_i]) {
(function(s) {
///
})(myArray[_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并提高了他的基准测试。
现在是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;
}
截至2019年，WebWorker已经更加流行，对于大型数据集，我们可以使用WebWorker通过充分利用多核处理器来更快地处理。
我们还有Parallel.js，这使得WebWorker更容易用于数据处理。
另一个jsperf.com测试:http://jsperf.com/while-reverse-vs-for-cached-length
反向while循环似乎是最快的。唯一的问题是while(——i)将停止于0。我怎么能访问数组[0]在我的循环那么?
我已经尝试了一些其他方法来迭代一个巨大的数组，并发现将数组长度减半，然后在一个循环中迭代这两部分更快。这种性能差异可以在处理大型数组时看到。
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循环与上面的方法之间的一些性能比较(使用timer.js)。
http://jsfiddle.net/tejzpr/bbLgzxgo/
