Benchmark: Reduce vs. ForEach in 2D array

Script Preparation code:

var array = [
    [1, 1, null, null, null, null],
    [1, null, null, 1, 1, null],
    [null, null, 1, 1, null, null, null],
    [1, 1, 1, 1, null, null]
];

Tests:

ForEach
const rightMostPosition = {x: 0, y: 0}; array.forEach((element, yIndex) => { const xIndex = element.reduceRight( (result, current, index) => result ?? (current && index) ); if (xIndex > rightMostPosition.x) { rightMostPosition.x = xIndex; rightMostPosition.y = yIndex; } });
Reduce
const rightMostPosition = array.reduce((position, currentArray, yIndex) => { const xIndex = currentArray.reduceRight( (result, currentBlock, index) => result ?? (currentBlock && index) ); if (position.x < xIndex) { position.x = xIndex; position.y = yIndex; } return position; }, {x: 0, y: 0});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ForEach
Reduce

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Description**

The benchmark is designed to compare two approaches for finding the last non-null index in a 2D array: using `forEach` and `reduce`.

**Script Preparation Code**

The script preparation code defines a 4x6 2D array, which will be used as input for both test cases.

```javascript
var array = [
    [1, 1, null, null, null, null],
    [1, null, null, 1, 1, null],
    [null, null, 1, 1, null, null, null],
    [1, 1, 1, 1, null, null]
];
```

**Html Preparation Code**

There is no HTML preparation code provided.

**Individual Test Cases**

The benchmark includes two test cases:

### ForEach

```javascript
const rightMostPosition = {x: 0, y: 0};
array.forEach((element, yIndex) => {
    const xIndex = element.reduceRight(
        (result, current, index) => result ?? (current && index)
    );
    if (xIndex > rightMostPosition.x) {
        rightMostPosition.x = xIndex;
        rightMostPosition.y = yIndex;
    }
});
```

This test case uses the `forEach` method to iterate over the 2D array, and for each element, it uses the `reduceRight` method to find the last non-null index in the element's row. The result is stored in the `rightMostPosition` object.

### Reduce

```javascript
const rightMostPosition = array.reduce((position, currentArray, yIndex) => {
    const xIndex = currentArray.reduceRight(
        (result, currentBlock, index) => result ?? (currentBlock && index)
    );
    if (position.x < xIndex) {
        position.x = xIndex;
        position.y = yIndex;
    }
    return position;
}, {x: 0, y: 0});
```

This test case uses the `reduce` method to iterate over the 2D array and find the last non-null index. The `reduceRight` method is used on each row of the array to find the last non-null element.

**Library Usage**

Both test cases use the following libraries:

* `Array.prototype.forEach`: a built-in JavaScript function for iterating over arrays.
* `Array.prototype.reduce`: a built-in JavaScript function for reducing an array to a single value.

The `reduceRight` method is not a standard JavaScript method, but it can be implemented using the `Array.prototype.reduce` method with some modifications (not shown in this example).

**Special JS Features/Syntax**

Neither test case uses any special JavaScript features or syntax. They only rely on built-in methods and basic JavaScript operations.

**Alternatives**

If you wanted to implement a similar benchmark, you could use other approaches such as:

* Using `map` and `Math.max` to find the last non-null index in each row.
* Using `every` and `filter` to find the last non-null element in each row.
* Implementing your own loop and logic to find the last non-null index.

Keep in mind that these alternatives may have different performance characteristics compared to using built-in methods like `forEach` and `reduce`.

Related benchmarks:

Reduce vs. ForEach in 2D array (version: 0)

Finding the last non-null index in a 2D array can be done in several ways, two of them are using a ForEach vs. a Reduce method.

Comparing performance of: ForEach vs Reduce

Created: 5 years ago by: Guest

Jump to the latest result

ForEach

Reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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