Benchmark: for uncached/cached vs. forEach

Script Preparation code:

var array = [];
for (var i=0, t=10000; i<t; i++) {
    array.push(Math.round(Math.random() * t))
}
var t=0;

Tests:

for let
for (let i = 0; i < array.length; i++) { t += array[i]; }
for const
for (const i = 0; i < array.length; i++) { t += array[i]; }
for var
for (var i = 0; i < array.length; i++) { t += array[i]; }
for let cached
let len=array.length; for (let i = 0; i < len; i++) { t += array[i]; }
for const cached
const len=array.length; for (const i = 0; i < len; i++) { t += array[i]; }
for var cached
var len=array.length; for (var i = 0; i < len; i++) { t += array[i]; }
forEach
array.forEach(function(v, i) { t += v; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for let
for const
for var
for let cached
for const cached
for var cached
forEach

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The benchmark being tested is the performance difference between various loop iteration methods: `for`, `forEach`, and different scoped versions (`let`, `const`) with caching.

**Loop Iteration Methods:**

1. **`for`**: This is a traditional, explicit loop that uses an incrementing counter variable.
2. **`forEach`**: This method is used for arrays and other iterable objects. It's often considered more concise than a traditional `for` loop.
3. **Scoped loops**:
	* `let`: Uses a scoped block to declare variables. In modern JavaScript, this is equivalent to `const`.
	* `const`: Similar to `let`, but the variable must be declared with `const`.
	* Cached versions: These use a cached length property to improve performance.

**Pros and Cons:**

1. **`for`**: Simple and easy to understand, but can lead to magic numbers (hardcoded values) if not used carefully.
2. **`forEach`**: More concise than traditional loops, but might be slower due to the overhead of the `forEach` method.
3. **Scoped loops**:
	* `let` and `const`: These are modern, scoped versions that help avoid variable hoisting issues.
	* Cached versions: Improve performance by reusing cached length values.

**Library Usage:**

In this benchmark, the `Array.prototype.forEach()` method is used for array iteration. The `forEach()` method is a built-in JavaScript function that takes two arguments: a callback function and an optional `this` context.

**Special JS Features/Syntax:**

None mentioned in this specific benchmark.

**Benchmark Results:**

The results show that:

* `for let` and `for const` are relatively close in performance, with slight variations depending on the browser and device.
* The cached versions (`for let cached`, `for const cached`) outperform their non-cached counterparts by a significant margin.
* `forEach` is slower than the scoped loops but still performs well.

**Alternatives:**

If you're looking for alternative loop iteration methods, consider:

1. **`while` loops**: Another traditional loop option that's often used in conjunction with manual counter variables.
2. **`for...of` loops**: A newer, more modern loop syntax that's gaining popularity.
3. **Async/await loops**: Suitable for asynchronous operations, these loops can help manage promises and callbacks.

Keep in mind that the choice of loop iteration method depends on your specific use case, performance requirements, and personal coding style.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for let	644.3 Ops/sec
for const	0.0 Ops/sec
for var	644.0 Ops/sec
for let cached	818.1 Ops/sec
for const cached	0.0 Ops/sec
for var cached	818.3 Ops/sec
forEach	1109.7 Ops/sec

Related benchmarks:

for uncached/cached vs. forEach (version: 0)

Comparing performance of: for let vs for const vs for var vs for let cached vs for const cached vs for var cached vs forEach

Created: 2 years ago by: Registered User

Jump to the latest result

for let

for const

for var

for let cached

for const cached

for var cached

forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):