What's the fastest way to loop through an array in JavaScript?

Question 1

I learned from books that you should write for loop like this:

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

so the arr.length will not be calculated each time.

Others say that the compiler will do some optimization to this, so you can just write:

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

I just want to know which is the best way in practice?

Question 2

also worth a look when dealing with array looping: jsperf.com/array-loop-var-caching

Question 3

@wong2 Tthis benchmark from Browserdiet has a more complete collection of alternatives.

Question 4

jsben.ch/#/y3SpC

Question 5

Improved on the previous jsben: jsben.ch/#/R6LbS

Question 6

It looks like the answer is constantly changing and dependent on the engine. If you need speed, just go with a standard for loop and leave out all of the extra tricks. While these special tricks let you trade readability for slightly faster code today, the engines will continue to evolve, and the special tricks may become less effective, potentially even making your code slightly slower.

Question 7

After performing this test with most modern browsers: https://jsben.ch/wY5fo

Currently, the fastest form of loop (and in my opinion the most syntactically obvious).

A standard for-loop with length caching

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

I would say, this is definitely a case where I applaud JavaScript engine developers. A runtime should be optimized for clarity, not cleverness.

Question 8

Interestingly, in IE9 this is faster: for (var i = 0, len = myArray.length; i < len; ++i) {} // prefix incr, instead of postfix

Question 9

See Prefer prefix operators over postfix for other reasons to use ++i.

Question 10

I tested using prefix operator as @BennettMcElwee suggested and it runs a little faster: for(var i=0, len=myArray.length; i<len; ++i) Check jsperf.com/caching-array-length/84

Question 11

You have to be careful using this loop. I started using it and had a hard to track bug because of one mistake I made. If you nest two loops like this: jsfiddle.net/KQwmL/1. You have to be careful to name the var len differently in the two loops, otherwise the second loop will overwrite the first len.

Question 12

@WillshawMedia You can declare multiple variables with a single var statement. How it is written, len is actually scoped as you suggest.

Question 13

The absolute fastest way to loop through a javascript array is:

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

See this post for a full comparison

Question 14

Don’t forget to use var (else len becomes a global variable). Also, see jsperf.com/loops for more loop benchmarks.

Question 15

The blog post this answer is based on is now almost 4 years old, and a lot has changed in js engines in that time, see my answer below for an updated comparison.

Question 16

I agree with @jondavidjohn. I tested this code and it turned out to be the less efficient... Check jsperf.com/caching-array-length/84

Question 17

The above answer is almost universally (across browsers) much much slower than a for-loop. See the JSPerf link in accepted answer. It is a great shame, cause it's extremely readable IMO.

Question 18

Im guessing @jondavidjohn that what you mean by 'my answer below' is 'my answer above' lol.

Question 19

As of June 2016, doing some tests in latest Chrome (71% of the browser market in May 2016, and increasing):

The fastest loop is a for loop, both with and without caching length delivering really similar performance. (The for loop with cached length sometimes delivered better results than the one without caching, but the difference is almost negligible, which means the engine might be already optimized to favor the standard and probably most straightforward for loop without caching).
The while loop with decrements was approximately 1.5 times slower than the for loop.
A loop using a callback function (like the standard forEach), was approximately 10 times slower than the for loop.

I believe this thread is too old and it is misleading programmers to think they need to cache length, or use reverse traversing whiles with decrements to achieve better performance, writing code that is less legible and more prone to errors than a simple straightforward for loop. Therefore, I recommend:

If your app iterates over a lot of items or your loop code is inside a function that is used often, a straightforward for loop is the answer:
```
for (var i = 0; i < arr.length; i++) {
 // Do stuff with arr[i] or i
}
```
If your app doesn't really iterate through lots of items or you just need to do small iterations here and there, using the standard forEach callback or any similar function from your JS library of choice might be more understandable and less prone to errors, since index variable scope is closed and you don't need to use brackets, accessing the array value directly:
```
arr.forEach(function(value, index) {
 // Do stuff with value or index
});
```
If you really need to scratch a few milliseconds while iterating over billions of rows and the length of your array doesn't change through the process, you might consider caching the length in your for loop. Although I think this is really not necessary nowadays:
```
for (var i = 0, len = arr.length; i < len; i++) {
 // Do stuff with arr[i]
}
```

Question 20

Nope. jsbench.github.io/#67b13d4e78cdd0d7a7346410d5becf12 shows that the fastest is "Reverse loop, implicit comparison, inlined code" (105,221 ops/sec) while "Loop, cached value, inlined code" scored only 76,635 ops/sec (Chrome 38.0.2125.111)

Question 21

@Fr0sT Your benchmark is a different scenario, traversing arrays from index 1 to <= length. Of course this is going to lead to different results. If you try traversing zero-based arrays with < length -- which seems to me it is the usual scenario -- you'll discover that the results are better optimized with a normal "for" loop (with cached length being slightly faster).

Question 22

Kyopaxa changed benchmarks to (0 <= i < length), results are the same. "Reverse loop, implicit comparison, function call" scored 365 kops/sec, while "Loop, cached value, inlined code" scored 350 kops/sec (FF 51)

Question 23

@Fr0sT if you change the zero-based cached for-loops with no equal comparison, such as for(let i=0, j=array.length; i < j; i++), the forward for loops speed up considerably. On a few tests I ran it won, on most it was within the margin of error or the reverse loop.

Question 24

@IsaacB and all, sorry I didn't notice that the bench is quite incorrect - all direct loops iterate 1..length while reverse loops iterate length..0 (arr[length] item is invalid). I fixed the tests and now they show the following results: "Loop, inlined code" 360,616 ops/sec ±0.27%, "Loop, cached value, inlined code" 345,786 ops/sec ±2.18% (Sic!) "Reverse loop, implicit comparison, inlined code" 322,640 ops/sec ±2.90% (!!!). Tests were executed by FF51. New bench is here jsbench.github.io/#6bdfcd2692ba80c16a68c88554281570. So it seems it's no sense in uglifying the loops.

Question 25

It's just 2018 so an update could be nice...

And I really have to disagree with the accepted answer. It differs on different browsers. Some do forEach faster, some for-loop, and some while here is a benchmark on all methods https://jsben.ch/mW36e

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

and since you can see a lot of for-loops like for(a = 0; ... ) then it's worth to mention that without 'var', variables will be defined globally and this can dramatically affect speed so it'll get slow.

Duff's device run faster on opera but not in 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>

Question 26

@Maykonn you probably wanted to say "and it works everywhere but Opera Mini"

Question 27

@Maykonn Which is not listed in the default view because 0.18% of all users have IE8 and you should not waste time trying to support it; in 2018 it's a dead horse.

Question 28

It is definitely true if you consider all users around the world. But, unfortunately, in specific parts of the world IE8 is relevant yet.

Question 29

If I may, not only different browsers will have different results with different methods, but same browsers will have different results with different inputs. A huge Number only Array will be very optimized, while a small mixed one won't.

Question 30

How about for..of and for..in?

Question 31

If the order is not important, I prefer this style:

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

It caches the length and is much shorter to write. But it will iterate over the array in reverse order.

Question 32

You just killed it.

Question 33

don't you need i >= 0;?

Question 34

@MarwaAhmad: No. i-- returns a number and once the number is 0 the condition is false because Boolean(0) === false.

Question 35

2014 While is back

Just think logical.

Look at this

for( var index = 0 , length = array.length ; index < length ; index++ ) {
 //do stuff
}

Need to create at least 2 variables (index,length)
Need to check if the index is smaller than the length
Need to increase the index
the for loop has 3 parameters

Now tell me why this should be faster than:

var length = array.length;
while( --length ) { //or length--
 //do stuff
}

One variable
No checks
the index is decreased (Machines prefer that)
while has only one parameter

I was totally confused when Chrome 28 showed that the for loop is faster than the while. This must have ben some sort of

"Uh, everyone is using the for loop, let's focus on that when developing for chrome."

But now, in 2014 the while loop is back on chrome. it's 2 times faster , on other/older browsers it was always faster.

Lately i made some new tests. Now in real world envoirement those short codes are worth nothing and jsperf can't actually execute properly the while loop, because it needs to recreate the array.length which also takes time.

you CAN'T get the actual speed of a while loop on jsperf.

you need to create your own custom function and check that with window.performance.now()

And yeah... there is no way the while loop is simply faster.

The real problem is actually the dom manipulation / rendering time / drawing time or however you wanna call it.

For example i have a canvas scene where i need to calculate the coordinates and collisions... this is done between 10-200 MicroSeconds (not milliseconds). it actually takes various milliseconds to render everything.Same as in DOM.

BUT

There is another super performant way using the for loop in some cases... for example to copy/clone an array

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

Notice the setup of the parameters:

Same as in the while loop i'm using only one variable
Need to check if the index is bigger than 0;
As you can see this approach is different vs the normal for loop everyone uses, as i do stuff inside the 3th parameter and i also decrease directly inside the array.

Said that, this confirms that machines like the --

writing that i was thinking to make it a little shorter and remove some useless stuff and wrote this one using the same style:

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

Even if it's shorter it looks like using i one more time slows down everything. It's 1/5 slower than the previous for loop and the while one.

Note: the ; is very important after the for looo without {}

Even if i just told you that jsperf is not the best way to test scripts .. i added this 2 loops here

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

And here is another answer about performance in javascript

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

This answer is to show performant ways of writing javascript. So if you can't read that, ask and you will get an answer or read a book about javascript http://www.ecma-international.org/ecma-262/5.1/

Question 36

This answer starts of very good. I to noticed that the last couple of years the for was faster then the while, and I once read on crome-dev it was exactly because of the reason you mention. It would be just a matter of time before while would catch up again. From that point on, the logic in the first part of your answer will hold (once again, yay)! However Modern implementations no longer rigidly follow every ecma-specified step (they optimize). Since now your engine is no longer the most noticeable bottle-neck, one can now actually notice the CPU cache-misses in reverse loops!

Question 37

Explain, so maybe i can correct the answer or learn something new. btw the answer is now more than a year old ... browsers may have changed over time as they always do...

Question 38

In my opinion, while( --length ) is evil because while it technically works because 0 is false, 0 and false aren't really truly the same thing semantically speaking.

Question 39

yeah... it's an older post now... but yeah i love the simplicity of while. And for sure as you mention it in both cases you need to know what to write. At the other side i never had the necessity to loop trough negative numbers.

Question 40

Be careful, index-- will evaluate to false when index is 0, which you don't want if you're iterating over everything in an array

Question 41

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

The latest revision of test, which I prepared (by reusing older one), shows one thing.

Caching length is not that much important, but it does not harm.

Every first run of the test linked above (on freshly opened tab) gives best results for the last 4 snippets (3rd, 5th, 7th and 10th in charts) in Chrome, Opera and Firefox in my Debian Squeeze 64-bit (my desktop hardware). Subsequent runs give quite different result.

Performance-wise conclusions are simple:

Go with for loop (forward) and test using !== instead of <.
If you don't have to reuse the array later, then while loop on decremented length and destructive shift()-ing array is also efficient.

tl;dr

Nowadays (2011.10) below pattern looks to be the fastest one.

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

Mind that caching arr.length is not crucial here, so you can just test for i !== arr.length and performance won't drop, but you'll get shorter code.

PS: I know that in snippet with shift() its result could be used instead of accessing 0th element, but I somehow overlooked that after reusing previous revision (which had wrong while loops), and later I didn't want to lose already obtained results.

Question 42

Creating variable insite the loop like let current = arr[i] can reduce a performance (big memory allocation)? Or would be better to declare current before the loop? Or use arr[i] in all places inside the loop?

Question 43

Declare any variables that the loop is going to use before the loop

Question 44

"Best" as in pure performance? or performance AND readability?

Pure performance "best" is this, which uses a cache and the ++prefix operator (my data: http://jsperf.com/caching-array-length/189)

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

I would argue that the cache-less for-loop is the best balance in execution time and programmer reading time. Every programmer that started with C/C++/Java won't waste a ms having to read through this one

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

Question 45

+1 for readability. No matter how well len is named, one would always have to do a double take on that first loop. The second loop's intention is obvious.

Question 46

**cache the array length inside the loop ,some seconds of time will be eluded . Depends on the items in the array if there are more items in array there is major difference with respect to Ms of time*

**

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

**

Question 47

This looks to be the fastest way by far...

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

Take into account that this will consume the array, eating it, and leaving nothing left...

Question 48

arr.shift(); instead of arr.pop() so that array reverse can be avoided.

Question 49

@Gargaroz if you are getting a JSON from a webservice for example a chat service or items on a product catalog. Another situation when you just need to use the array once can be for example a chart that gets many coordinates on a intervall basis. There are many examples.

Question 50

Cool, thank you for the explanation, very kind of you; can you point me in the direction where I may find further examples to exploit this kind of loop?

Question 51

Currently in Chrome 53 and Firefox 48 it's one of the slowest approach - check on perfjs.info/array-iteration

Question 52

@Alireza agree, I have a comment for that in my answer also.

Question 53

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 │
└─────────┴───────────────────────┴────────────┴──────────┘

Tested on Macbook Air M1 2020. NodeJS 18.

For arrays with 10_000_000 elements, the standard for loop wins. For other cases see my gist: https://gist.github.com/episage/076ded007d0583f6a275f93a8c9c8047#file-result-txt

Shoutout to @DungGramer. I fixed bugs and enhanced his benchmark.

Question 54

Interesting answer, think its nice and up to date and simple. Would be cool if you could show an example of each type.

Question 55

@GreggoryWiley You can see each type example in the gist link (scroll up)

Question 56

Great work. I came here comparing for(x of array), array.foreach() and the 60 years old classic for loop with index access and index increment where I couldn't believe the classic loops was faster than the other two. Attempt to guess a reason: foreach has a function call for each loop and for-of has the iterator for which I don't get why it should be slower than the classic loop.

Question 57

It's the year 2017.

I made some tests.

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

Looks like the while method is the fastest on Chrome.

Looks like the left decrement (--i) is much faster than the others (++i, i--, i++) on Firefox.

This approach is the fasted on average. But it iterates the array in reversed order.

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

If the forward order is important, use this approach.

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

Question 58

By using the keyword let you are actually comparing scope creation performance instead of loop performance. Using let i = 0, ii = array.length in your for loops will create a new scope for those variables inside the for block. Your while examples do not create a new scope for the variables inside the while block and that's why they are faster. If you use var instead of let in your for loops, you'll see how for loops are still as fast as whiles in 2017, but more readable.

Question 59

Here is a jsperf of what I am talking about: jsperf.com/javascript-loop-testing-let-vs-var

Question 60

This is only an issue in Chrome. In other Browsers var and let have the same performance - stackoverflow.com/a/32345435/1785975

Question 61

Interesting. Anyways, I don't find the statement of "while being faster in Chrome" accurate. It's only if using let due to performance issues of that keyword in Chrome. If using var or with other browsers, for and while are pretty much the same, sometimes for is even faster depending of the benchmark, and it is more compact and readable imho.

Question 62

I have a test all way in here. Check this! https://gist.github.com/DungGramer/7efdfefecaa1b8f5d6510202524dc751

My result:

pop is fastest, forEach is goodest for readable and fast
do..while faster than for
loop faster if no have condition (like if)
--i is fastest

Question 63

Your code is incorrect for pop. arrClone is empty when you try to iterate it

Question 64

I made an updated version over here: gist.github.com/episage/076ded007d0583f6a275f93a8c9c8047 . for ++ wins for large arrays.

jondavidjohn 62.5k21 gold badges120 silver badges159 bronze badges · Accepted Answer · 2011-08-31 03:00:28Z

425

After performing this test with most modern browsers: https://jsben.ch/wY5fo

Currently, the fastest form of loop (and in my opinion the most syntactically obvious).

A standard for-loop with length caching

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

I would say, this is definitely a case where I applaud JavaScript engine developers. A runtime should be optimized for clarity, not cleverness.

Share

Improve this answer

edited Jul 25, 2024 at 13:22

aioobe's user avatar

aioobe

423k115 gold badges831 silver badges844 bronze badges

answered Aug 31, 2011 at 3:00

jondavidjohn's user avatar

jondavidjohn

62.5k21 gold badges120 silver badges159 bronze badges

Sign up to request clarification or add additional context in comments.

26 Comments

Christopher Bennage

Christopher Bennage Over a year ago

Interestingly, in IE9 this is faster: for (var i = 0, len = myArray.length; i < len; ++i) {} // prefix incr, instead of postfix

2011年10月31日T17:38:32.533Z+00:00

Bennett McElwee

Bennett McElwee Over a year ago

See Prefer prefix operators over postfix for other reasons to use ++i.

2011年11月21日T08:28:57.693Z+00:00

victmo

victmo Over a year ago

I tested using prefix operator as @BennettMcElwee suggested and it runs a little faster: for(var i=0, len=myArray.length; i<len; ++i) Check jsperf.com/caching-array-length/84

2012年03月22日T04:33:41.483Z+00:00

Rui Marques

Rui Marques Over a year ago

You have to be careful using this loop. I started using it and had a hard to track bug because of one mistake I made. If you nest two loops like this: jsfiddle.net/KQwmL/1. You have to be careful to name the var len differently in the two loops, otherwise the second loop will overwrite the first len.

2012年11月30日T13:08:47.163Z+00:00

jondavidjohn

jondavidjohn Over a year ago

@WillshawMedia You can declare multiple variables with a single var statement. How it is written, len is actually scoped as you suggest.

2013年09月19日T15:10:44.563Z+00:00

|

CollectivesTM on Stack Overflow

What's the fastest way to loop through an array in JavaScript?

25 Answers 25

26 Comments

9 Comments

9 Comments

8 Comments

3 Comments

5 Comments

2 Comments

1 Comment

Comments

5 Comments

3 Comments

4 Comments

My result:

2 Comments

Comments

2 Comments

1 Comment

Comments

Comments

to sum up,

Comments

Comments

1 Comment

Comments

2 Comments

Comments

7 Comments

Linked

Hot Network Questions

CollectivesTM on Stack Overflow

25 Answers 25

26 Comments

9 Comments

9 Comments

8 Comments

3 Comments

5 Comments

2 Comments

1 Comment

Comments

5 Comments

3 Comments

4 Comments

My result:

2 Comments

Comments

2 Comments

1 Comment

Comments

Comments

to sum up,

Comments

Comments

1 Comment

Comments

2 Comments

Comments

7 Comments

Linked

Related