Benchmark: foreach vs for vs for (length var) vs for..in vs for..of

Script Preparation code:

var array = new Array(1000);
for(i=0; i<array.length; i++){
  array[i] = Math.random();
}

Tests:

forEach
array.forEach(function(i) { i; })
for
for (var i = 0; i < array.length; i++) { array[i]; }
for with length var
for (var i = 0, n = array.length; i < n; i++) { array[i]; }
for..in
for (var i in array) { array[i]; }
for..of
for (var i of array) { i; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for
for with length var
for..in
for..of

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
forEach	2734531.2 Ops/sec
for	7022.2 Ops/sec
for with length var	15543.5 Ops/sec
for..in	10964.2 Ops/sec
for..of	374752.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different JavaScript loops is an essential task for any developer, and MeasureThat.net provides a great platform for doing so.

**What is being tested?**

In this benchmark, four different types of loops are compared:

1. `forEach`: A loop that iterates over an array using the `Array.prototype.forEach` method.
2. `for`: A traditional loop that uses a variable to keep track of the iteration index.
3. `for with length var`: A variant of the traditional loop that uses a variable to store the length of the array, allowing for more efficient indexing.
4. `for..in`: A loop that iterates over an object using its property names (i.e., the keys).
5. `for..of`: A new type of loop introduced in ECMAScript 2015 (ES6), which allows iterating over iterable objects, such as arrays.

**Options compared**

Each test case compares two or more different implementations of each loop type. This allows us to evaluate the performance differences between these various approaches.

**Pros and cons of each approach:**

* `forEach`:
	+ Pros: Simple and concise syntax, easy to read and write.
	+ Cons: Can be slower than other methods due to the overhead of the `Array.prototype.forEach` method call.
* `for`:
	+ Pros: Fast and efficient for small arrays or performance-critical code.
	+ Cons: Requires more manual management of indices, which can lead to errors if not done correctly.
* `for with length var`:
	+ Pros: Faster than traditional loops when dealing with large arrays, since it avoids the overhead of indexing calculations.
	+ Cons: May be less readable for developers unfamiliar with this syntax.
* `for..in`:
	+ Pros: Allows iterating over objects using their property names, which can be useful in certain scenarios.
	+ Cons: Can lead to issues when dealing with arrays or other types of iterables that don't have property names (e.g., strings).
* `for..of`:
	+ Pros: New and efficient way to iterate over iterable objects, such as arrays, while maintaining readability.
	+ Cons: Still a relatively new feature, and some older browsers may not support it.

**Library usage**

In this benchmark, the `Array.prototype.forEach`, `for...in`, and `for...of` methods are used. These methods are part of the JavaScript standard library and do not require any additional libraries or dependencies.

**Special JS features/syntax**

This benchmark uses ES6+ syntax for the `for..of` loop. This is a relatively recent feature introduced in ECMAScript 2015, which allows iterating over iterable objects using the `for...of` loop.

**Alternatives**

If you need to measure the performance of different loops in JavaScript, here are some alternatives:

* Benchmark.js: A popular benchmarking library for Node.js and web applications.
* jsperf: A simple benchmarking tool that can be used in web browsers or Node.js environments.
* Google's V8 Profiler: A powerful profiling tool for identifying performance bottlenecks in V8-based JavaScript engines (used by Chrome, Node.js, etc.).

Keep in mind that different benchmarking tools and methods may provide varying results depending on the specific use case and environment.

Related benchmarks:

foreach vs for vs for (length var) vs for..in vs for..of (version: 1)

Compare loop performance

Comparing performance of: forEach vs for vs for with length var vs for..in vs for..of

Created: 4 years ago by: Registered User

Jump to the latest result

forEach

for

for with length var

for..in

for..of

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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