Benchmark: for(by cache) vs foreach vs some vs every vs for..of vs map for large set

Script Preparation code:

var array = new Array(1000000);

Tests:

for
const size = array.length; for (var i = 0; i < size; i++) { array[i]; }
foreach
array.forEach(function(i) { array[i]; });
some
array.some(function(i) { array[i]; });
every
array.every(function(i) { array[i]; });
for..of
for (var i of array) { array[i]; }
map
array.map(a => a);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
foreach
some
every
for..of
map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/111.0.5563.72 Mobile/15E148 Safari/604.1

Browser/OS: Chrome Mobile iOS 111 on iOS 16.3

View result in a separate tab

Test name	Executions per second
for	27.7 Ops/sec
foreach	53.7 Ops/sec
some	38.4 Ops/sec
every	1680.0 Ops/sec
for..of	7.2 Ops/sec
map	36.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark compares the performance of different loop constructs in JavaScript:

1. `for` loop
2. `forEach` loop
3. `some` loop
4. `every` loop
5. `for..of` loop (introduced in ECMAScript 2015)
6. `map` function

The benchmark is designed to test the performance of each loop construct on a large array of 1,000,000 elements.

**Loop Constructs**

Here's a brief explanation of each loop construct:

1. **`for` loop**: A traditional loop that uses an explicit counter variable and increments it at each iteration.
2. **`forEach` loop**: A loop that iterates over an array or object using the `forEach` method, which calls a callback function for each element.
3. **`some` loop**: A loop that returns `true` as soon as a condition is met, otherwise returns `false`. It's often used with callbacks to check if any elements in an array meet a certain condition.
4. **`every` loop**: A loop that returns `true` only if all elements in an array meet a certain condition, otherwise returns `false`.
5. **`for..of` loop** (introduced in ECMAScript 2015): A new type of loop that iterates over arrays and other iterable objects using the `for...of` statement.
6. **`map` function**: A function that creates a new array with the results of applying a transformation to each element of an original array.

**Library Used**

The benchmark uses the `array` object, which is a built-in JavaScript object that represents an array.

**Performance Comparison**

The benchmark compares the performance of each loop construct by executing each one on the large array and measuring the time taken. The results are displayed in the format:

* `RawUAString`: A string representing the user agent of the browser used to execute the test.
* `Browser`: The name of the browser used to execute the test.
* `DevicePlatform`: The device platform used to execute the test (e.g., Mobile).
* `OperatingSystem`: The operating system used to execute the test (e.g., iOS 16.3).
* `ExecutionsPerSecond`: The number of executions per second for each loop construct.

**Pros and Cons**

Here are some pros and cons of each loop construct:

1. **`for` loop**: Pros: simple, flexible; Cons: can be error-prone if not used carefully.
2. **`forEach` loop**: Pros: concise, easy to read; Cons: may have performance overhead due to callback function calls.
3. **`some` loop**: Pros: convenient for checking conditions; Cons: may return early, which can affect performance.
4. **`every` loop**: Pros: convenient for checking conditions; Cons: may return false if any elements fail the condition.
5. **`for..of` loop** (introduced in ECMAScript 2015): Pros: concise, easy to read; Cons: may have performance overhead due to array iteration.
6. **`map` function**: Pros: concise, easy to use; Cons: creates a new array, which can consume memory.

**Special JavaScript Features**

The benchmark uses the `for...of` loop and the `map` function, which are special features introduced in ECMAScript 2015.

**Alternatives**

If you need to implement loops or transformations on arrays, consider using:

1. **`forEach` method**: For iterating over arrays and executing callback functions for each element.
2. **`filter` method**: For creating a new array with elements that meet a certain condition.
3. **`reduce` method**: For reducing an array to a single value based on a transformation.

Keep in mind that the choice of loop construct or function depends on the specific use case and performance requirements.

Related benchmarks:

for(by cache) vs foreach vs some vs every vs for..of vs map for large set (version: 0)

Compare loop performance

Comparing performance of: for vs foreach vs some vs every vs for..of vs map

Created: one year ago by: Registered User

Jump to the latest result

for

foreach

some

every

for..of

map

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):