Benchmark: for loop vs Array.some vs for of

Script Preparation code:

var array = Array.from(Array(1000), (_, i) => i);

Tests:

for
var result = false; for (let i = 0; i < array.length; ++i) { const item = array[i]; if (item > 500) { result = true; break; } }
some
let result = array.some(item => item > 500);
for of
let result = false; for (const item of array) { if (item > 500) { result = true; break; } }

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

some

2.8M/s

for of

2.1M/s

for

410K/s

Fastest: some (6.8x faster)

View exact numbers

✓ some: 2,786,938 ops/sec
• for of: 2,066,592 ops/sec
• for: 410,500 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
some
for of

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 months ago)

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

Browser/OS: Chrome 142 on Windows

View result in a separate tab

some

3.1M/s

for of

2.1M/s

for

457K/s

View exact numbers

Test name	Executions per second
✓ some	3,050,017 Ops/sec
for of	2,076,535 Ops/sec
for	456,788 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of three loop types in JavaScript:

1. Traditional `for` loop
2. `Array.prototype.some()` method
3. `for...of` loop (also known as iterator loops)

**Loop Types Comparison**

Each loop type has its own strengths and weaknesses, which are discussed below:

### 1. Traditional `for` Loop

A traditional `for` loop iterates over an array by using the index to access each element. The loop continues until a certain condition is met or the end of the array is reached.

**Pros:**

* Easy to understand and implement
* Suitable for situations where you need direct access to the index and the element

**Cons:**

* Can be slower than other methods, especially for large arrays
* Requires manual management of the loop counter and array bounds

### 2. `Array.prototype.some()` Method

`Array.prototype.some()` is a method that returns `true` if at least one element in the array satisfies the provided callback function.

**Pros:**

* Fast and efficient, as it only iterates over the elements until it finds a match
* Convenient for situations where you don't need direct access to the index

**Cons:**

* Can be slower than traditional `for` loops if the callback function is computationally expensive
* May not work well with arrays that contain null or undefined values, as it returns false in such cases

### 3. `for...of` Loop (Iterator Loops)

`for...of` loops are a modern way of iterating over arrays and other iterable objects using iterators.

**Pros:**

* Fast and efficient, similar to `Array.prototype.some()`
* Allows for easy iteration over the elements without manual index management
* Supports iterator operations like `next()` and `return`

**Cons:**

* Less well-known than traditional `for` loops or `Array.prototype.some()`
* May require more setup and understanding of iterators

**Library Usage**

None of the provided benchmark tests use any external libraries.

**Special JavaScript Features**

The benchmark tests do not utilize any special JavaScript features like `async/await`, Web Workers, or WebSockets. However, it's worth noting that the `for...of` loop relies on the ECMAScript 2015 standard, which introduces iterator syntax.

**Benchmark Preparation Code**

The provided script preparation code creates an array of 1000 elements using `Array.from()` and assigns it to the variable `array`. This setup allows for a consistent benchmarking environment across different loop types.

**Alternative Loop Types**

Other alternatives to traditional loops include:

* `while` loops
* Recursive functions (although not recommended due to performance issues)
* Closures or higher-order functions (for more complex iteration scenarios)

However, it's essential to note that the choice of loop type depends on the specific use case and requirements. The provided benchmark compares a simple iteration scenario, while in real-world applications, you may need to consider more complex iteration patterns and optimizations.

for loop vs Array.some vs for of (version: 0) Benchmark.js

Compare loop performance

Comparing performance of: `for vs some vs for of`

Created: 5 years ago by: Registered User

Go to the latest result

for

some

for of

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

for loop vs Array.some vs for of (version: 0) Benchmark.js

Compare loop performance

Comparing performance of: for vs some vs for of

Created: 5 years ago by: Registered User

Go to the latest result

for

some

for of

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `for vs some vs for of`