Benchmark: Different ways of iterating through an array, two elements at a time

Script Preparation code:

var a = [];
for (let i = 0; i < 1000; i++)
  a.push(i);

Tests:

++i, division and multiplication
for (let i = 0, l = a.length / 2; i < l; ++i) a[i * 2] + a[i * 2 + 1];
++i and bit shift
for (let i = 0, l = a.length >> 1; i < l; ++i) a[i << 1] + a[(i << 1) + 1];
i += 2
for (let i = 0, l = a.length - 1; i < l; i += 2) a[i] + a[i + 1];
++i, ++i
for (let i = 0, l = a.length - 1; i < l; ++i, ++i) a[i] + a[i + 1];
++i, [++i]
for (let i = 0, l = a.length - 1; i < l; ++i) a[i] + a[++i];
[++i], [++i]
for (let i = -1, l = a.length - 2; i < l;) a[++i] + a[++i];
[i++], [i++]
for (let i = 0, l = a.length - 1; i < l;) a[i++] + a[i++];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
++i, division and multiplication
++i and bit shift
i += 2
++i, ++i
++i, [++i]
[++i], [++i]
[i++], [i++]

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36

Browser/OS: Chrome 100 on Windows

View result in a separate tab

Test name	Executions per second
++i, division and multiplication	10548.7 Ops/sec
++i and bit shift	10729.3 Ops/sec
i += 2	10966.3 Ops/sec
++i, ++i	10628.6 Ops/sec
++i, [++i]	10966.3 Ops/sec
[++i], [++i]	10916.4 Ops/sec
[i++], [i++]	10755.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Measuring the performance of different iteration methods in JavaScript can be a fascinating exercise.

In this benchmark, we're comparing six different approaches to iterate through an array:

1. `for (let i = 0; i < l; ++i)`
2. `for (let i = 0, l = a.length / 2; i < l; ++i)`
3. `for (let i = 0, l = a.length - 1; i < l; i += 2)`
4. `for (let i = 0, l = a.length - 1; ++i, ++i)`
5. `for (let i = 0, l = a.length - 1; ++i)` and `a[i++]`
6. `for (let i = -1, l = a.length - 2; ++i)` and `++i`

Let's break down each approach:

**Approach 1: Simple increment (`++i`)**

Pros: Easy to read and write, doesn't require any special syntax or tricks.

Cons: May be slower due to the overhead of incrementing a variable.

**Approach 2: Bitwise shift (`a.length >> 1`)**

This approach uses bitwise operations to divide the array length by 2. This can be faster than simple division because bitwise shifts are generally faster than arithmetic operations.

Pros: Can be faster due to the efficiency of bitwise shifts.

Cons: May require more mental effort to understand, as it relies on a specific JavaScript feature (bitwise shift).

**Approach 3: Increment and increment (`i += 2`)**

This approach increments `i` by 2 in each iteration. This can be faster than simple increment because it reduces the number of iterations required.

Pros: Can be faster due to reduced iterations.

Cons: May require more complex logic to manage the index, as the increment is not straightforward.

**Approach 4: Post-increment (`a[i++]`)**

This approach uses post-increment, which increments `i` only after the value has been accessed. This can be faster than simple increment because it avoids reassigning the value of `i`.

Pros: Can be faster due to reduced overhead.

Cons: May require more complex logic to manage the index, as the increment is not straightforward.

**Approach 5: Pre-increment (`++i`)**

This approach uses pre-increment, which increments `i` before its value is accessed. This can be slower than post-increment because it reassigns the value of `i`.

Pros: None.

Cons: May be slower due to reassignment of `i`.

**Approach 6: Negative index (`++i`)**

This approach starts with an index of -1 and increments it in each iteration. This can be faster than simple increment because it allows for more efficient use of the array bounds.

Pros: Can be faster due to reduced overhead.

Cons: May require more complex logic to manage the index, as the starting value is negative.

The results show that approach 2 (bitwise shift) and approach 6 (negative index) are generally the fastest, while approach 1 (simple increment) is the slowest. Approach 4 (post-increment) and approach 3 (increment and increment) have similar performance characteristics, while approach 5 (pre-increment) is consistently slower.

Keep in mind that these results may vary depending on the specific use case and JavaScript environment being used. It's essential to experiment with different approaches to find the most efficient solution for your specific problem.

Related benchmarks:

Different ways of iterating through an array, two elements at a time (version: 1)

Comparing performance of: ++i, division and multiplication vs ++i and bit shift vs i += 2 vs ++i, ++i vs ++i, [++i] vs [++i], [++i] vs [i++], [i++]

Created: 3 years ago by: Registered User

Jump to the latest result

++i, division and multiplication

++i and bit shift

i += 2

++i, ++i

++i, [++i]

[++i], [++i]

[i++], [i++]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):