MeasureThat.net

 Array looping v2 (version: 0)

Finding out the fastest way to loop through an array

Comparing performance of: Simple for loop vs Simple for loop (reverse) vs Array.forEach vs for loop + Array.entries vs while + Array.entries vs enumerable for loop (order not important) vs enumerable for loop (order is respected) vs Array.map vs Array.filter vs while + Array.entries (condensed) vs for loop + Array.entries (condensed) vs Simple for loop (condensed) vs Instructionless for loop

Created: 2 years ago by: Guest
Jump to the latest result
Script Preparation code:
​x
 
var arr = [];
​
for( var cpt = 0; cpt < 100000; cpt++ ) {
  arr.push( Math.random() );
}
​
var someFn = function( item ) {
  return item * 3 + item / 5;
}
Tests:

  • Simple for loop

     
    for( var i = 0, n = arr.length; i < n; i++ ) {
        someFn( arr[ i ] );
    }

  • Simple for loop (reverse)

     
    for( var i = arr.length; i > -1; i-- ) {
        someFn( arr[ i ] );
    }

  • Array.forEach

     
    arr.forEach( someFn );

  • for loop + Array.entries

     
    for( var e = arr.entries(), n = e.next(); ! n.done; n = e.next() ) {
        someFn( n.value[ 1 ] );
    }

  • while + Array.entries

     
    var e = arr.entries(), n = e.next();
    while( ! n.done ) {
        someFn( n.value[ 1 ] );
        n = e.next();
    }

  • enumerable for loop (order not important)

     
    for( var i in arr ) {
        someFn( arr[ i ] );
    }

  • enumerable for loop (order is respected)

     
    for( r of arr ) {
        someFn( r );
    }

  • Array.map

     
    arr.map( someFn );

  • Array.filter

     
    arr.filter( someFn );

  • while + Array.entries (condensed)

     
    var e = arr.entries(), n;
    while( ! ( n = e.next() ).done ) {
        someFn( n.value[ 1 ] );
    }

  • for loop + Array.entries (condensed)

     
    for( var e = arr.entries(), n; ! (n = e.next()).done; ) {
        someFn( n.value[ 1 ] );
    }

  • Simple for loop (condensed)

     
    for( var i = 0, n = arr.length; i < n; ) {
        someFn( arr[ i++ ] );
    }

  • Instructionless for loop

     
    for( var i = 0, n = arr.length; i < n; someFn( arr[ i++ ] ) ) ;
Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

  • Test case name Result
    Simple for loop
    Simple for loop (reverse)
    Array.forEach
    for loop + Array.entries
    while + Array.entries
    enumerable for loop (order not important)
    enumerable for loop (order is respected)
    Array.map
    Array.filter
    while + Array.entries (condensed)
    for loop + Array.entries (condensed)
    Simple for loop (condensed)
    Instructionless for loop

    Fastest: N/A

    Slowest: N/A

Latest run results:
Run details: (Test run date: 2 years ago)
Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:106.0) Gecko/20100101 Firefox/106.0
Firefox 106 on Ubuntu
View result in a separate tab
Test name Executions per second
Simple for loop 9672.6 Ops/sec
Simple for loop (reverse) 822.0 Ops/sec
Array.forEach 8897.6 Ops/sec
for loop + Array.entries 449.8 Ops/sec
while + Array.entries 443.8 Ops/sec
enumerable for loop (order not important) 45.1 Ops/sec
enumerable for loop (order is respected) 366.7 Ops/sec
Array.map 748.7 Ops/sec
Array.filter 625.1 Ops/sec
while + Array.entries (condensed) 693.2 Ops/sec
for loop + Array.entries (condensed) 686.8 Ops/sec
Simple for loop (condensed) 9572.2 Ops/sec
Instructionless for loop 9568.6 Ops/sec
LLMs can make mistakes. Check important info.
Related benchmarks: