Benchmark: Measure iterations3

Script Preparation code:

function filter(iterable, predicate) {
    const iter = iterable[Symbol.iterator]();
    
    return {
        [Symbol.iterator]() {
            return this;
        },
        next() {
            let result;
          
          	while (
              !(result = iter.next()).done &&
              !predicate(result.value)
            );
          
          	return result;
        }
    };
}

function* filterGenerator(iterable, predicate){
    for (const value of iterable) {
        if (predicate(value)) {
            yield value;
        }
    }
}

var arr = Array(100).fill(0).map((_, i) => i + 1);
var predicate = (x) => x % 3 === 0 && x % 5 === 0;

var test1 = 0, test2 = 0, test3 = 0, test4 = 0, test5 = 0;

Tests:

Loop with conditions
for (const value of arr) { if (predicate(value)) { test1 += value; } } console.log(test1, 'test1');
Iterator
for (const value of filter(arr, predicate)) { test2 += value; } console.log(test2, 'test2');
Generator
for (const value of filterGenerator(arr, predicate)) { test3 += value; } console.log(test3, 'test3');
.forEach
arr.forEach((x) => { if (predicate(x)) test4 += x; }); console.log(test4, 'test4');
fori
for (let i = 0; i < arr.length; i++) { if (predicate(arr[i])) { test5 += arr[i]; } } console.log(test5, 'test5');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Loop with conditions
Iterator
Generator
.forEach
fori

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 explanation of the provided benchmark.

**Benchmark Overview**

The benchmark measures the performance of different JavaScript iteration methods: `for` loop with conditions, iterator, generator, `.forEach()`, and `for` loop without iterating over the array length (`fori`). The goal is to compare their execution speeds.

**Iteration Methods Compared**

1. **`for` loop with conditions**: This method uses a traditional `for` loop with an incrementing variable. It checks each element in the array against a predicate function, adding the element to a test value if it matches.
2. **Iterator**: An iterator is created using the `filter()` method, which returns an iterator object that yields values based on a predicate function. In this benchmark, the iterator is used to filter the elements of the array and add them to a test value.
3. **Generator**: A generator is created using the `filterGenerator()` function, which uses a similar approach as the iterator but returns a generator function instead. The generator yields values based on the predicate function.
4. **`.forEach()`**: This method uses the `.forEach()` array method to iterate over the elements of the array and add them to a test value if they match the predicate condition.
5. **`for` loop without iterating over the array length (`fori`)**: This method is similar to the traditional `for` loop with conditions but skips the incrementing variable, relying on the array's `length` property to control the iteration.

**Pros and Cons of Each Approach**

1. **`for` loop with conditions**:
	* Pros: Simple, straightforward implementation.
	* Cons: Can be slow due to the overhead of the incrementing variable and branching.
2. **Iterator**:
	* Pros: Efficient use of memory and CPU resources.
	* Cons: May have a slight performance hit due to the creation of an iterator object.
3. **Generator**:
	* Pros: Similar efficiency benefits as iterators, with the added benefit of being able to suspend execution.
	* Cons: Requires additional setup and may have slightly higher overhead due to generator functions.
4. **`.forEach()`**:
	* Pros: Simple and straightforward implementation.
	* Cons: May be slower than other methods due to the overhead of array iteration.
5. **`fori`**:
	* Pros: Simple and efficient, as it avoids unnecessary incrementing variables.
	* Cons: May have a slight performance hit due to relying on the `length` property.

**Library Used**

In this benchmark, the `filter()` method is used to create an iterator. This method is a part of the built-in JavaScript array prototype and does not require any external libraries.

**Special JS Feature or Syntax**

The generator function (`filterGenerator()`) uses a special syntax called a **generator function**, which allows it to suspend execution and yield values on demand. This feature is available in ECMAScript 2015 (ES6) and later versions.

Now that we've covered the benchmark, let's talk about alternatives:

1. **Other iteration methods**: There are other JavaScript iteration methods available, such as `map()`, `reduce()`, and `Array.prototype.forEach.call()`. However, these methods may have different use cases or performance characteristics compared to the methods in this benchmark.
2. **Closures**: Instead of using a generator function, you could use a closure-based approach to create an iterator. This would involve defining a function that captures the state of the iteration and yields values based on the predicate condition.
3. **Third-party libraries**: There are various third-party libraries available that provide efficient iteration methods for JavaScript arrays, such as Lodash's `_.filter()` or `_.forEach()`. These libraries may offer additional features or optimizations not present in the built-in methods.

Latest run results:

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

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

Browser/OS: Yandex Browser 24 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Loop with conditions	113288.4 Ops/sec
Iterator	171068.2 Ops/sec
Generator	175948.3 Ops/sec
.forEach	113089.9 Ops/sec
fori	57088.4 Ops/sec

Related benchmarks:

Measure iterations3 (version: 0)

Comparing performance of: Loop with conditions vs Iterator vs Generator vs .forEach vs fori

Created: 4 months ago by: Guest

Jump to the latest result

Loop with conditions

Iterator

Generator

.forEach

fori

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