Benchmark: some vs for..of (with condition)

Script Preparation code:

var largeArray = [];
for (let i = 0; i < 10000; i++) {
    // prevent clever optimizations for addition
    // binary value 1001
    largeArray.push(i * 9);
}
var smallArray = [];
for (let i = 0; i < 100; i++) {
    // prevent clever optimizations for addition
    // binary value 1001
    smallArray.push(i * 9);
}

Tests:

some largeArray
let result = 0; largeArray.some((i) => { if (i % 7 === 0) { result += i; return false; } if (i === 9999) { result += i; return true; } return false; });
For...of largeArray
let result = 0; for (const i of largeArray) { if (i % 7 === 0) { result += i; continue; } if (i === 9999) { result += i; break; } }
some smallArray
let result = 0; smallArray.some((i) => { if (i % 7 === 0) { result += i; return false; } if (i === 99) { result += i; return true; } return false; });
for...of smallArray
let result = 0; for (const i of smallArray) { if (i % 7 === 0) { result += i; continue; } if (i === 99) { result += i; break; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
some largeArray
For...of largeArray
some smallArray
for...of smallArray

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 YaBrowser/23.3.3.764 Yowser/2.5 Safari/537.36

Browser/OS: Yandex Browser 23 on Linux

View result in a separate tab

Test name	Executions per second
some largeArray	394749.4 Ops/sec
For...of largeArray	283285.7 Ops/sec
some smallArray	5131718.5 Ops/sec
for...of smallArray	7563465.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript loops is crucial in understanding how different browsers and engines optimize and execute code.

**What is tested:**

The provided JSON represents four individual test cases, each comparing the performance of two approaches:

1. `some` vs. `for...of`
2. `some` vs. `for...of` on a smaller array (`smallArray`)
3. `for...of` vs. `some` on a larger array (`largeArray`)
4. `for...of` vs. `some` on an even smaller array (`smallArray`)

**Options compared:**

The test cases compare two approaches for each iteration:

* `some`: Returns `true` if the current element passes the test, and `false` otherwise. This approach allows the engine to stop iterating as soon as a match is found.
* `for...of`: Iterates over an array using a loop that increments a counter variable (`i`) until it reaches the end of the array.

**Pros and Cons:**

### Some

Pros:

* Can terminate early if the condition is met, which can lead to better performance in certain cases.
* Allows engines to optimize the loop by stopping early.

Cons:

* May be slower for smaller arrays due to the overhead of the `if` statement.
* Can be less efficient than `for...of` when the array is large and most elements don't match the condition.

### For...of

Pros:

* Can handle any iterable, not just arrays.
* Can be more efficient for larger arrays since it doesn't require explicit loop counters or conditional statements.

Cons:

* May incur overhead due to the use of an iterator protocol.
* Can be slower than `some` if most elements don't match the condition.

**Library usage:**

None of the provided test cases use any external libraries. The arrays are created using native JavaScript syntax.

**Special JS features or syntax:**

There is no special JavaScript feature or syntax used in these test cases. The focus is on comparing two basic loop constructs: `some` and `for...of`.

**Alternatives:**

If you're interested in exploring other alternatives, here are a few options:

1. **Loops**: Compare the performance of different types of loops, such as `while`, `do-while`, or custom loop constructs.
2. **Array methods**: Measure the performance of various array methods like `map()`, `filter()`, or `reduce()`.
3. **Closure-based loops**: Test the performance of loops that use closures to iterate over data structures.
4. **Web Workers**: Compare the performance of web workers when executing different types of loops.

Keep in mind that these alternatives would require additional test cases and setup, but they could provide valuable insights into various aspects of JavaScript performance optimization.

Related benchmarks:

some vs for..of (with condition) (version: 0)

some vs for...of

Comparing performance of: some largeArray vs For...of largeArray vs some smallArray vs for...of smallArray

Created: 3 years ago by: Guest

Jump to the latest result

some largeArray

For...of largeArray

some smallArray

for...of smallArray

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