Benchmark: array partition - MeasureThat.net

Script Preparation code:

var contracts = [{
        address: "0xD4933879BaC3F7f76AADC6395650f41553d6aaaa",
        tokenIds: [],
    },

    {
        address: "0xD4933879BaC3F7f76AADC6395650f41553d6bbbb",
        tokenIds: [],
    },
    {
        address: "0xD4933879BaC3F7f76AADC6395650f41553d6cccc",
        tokenIds: ["1", "2", "3", "4", "5"],
    },
];

var arr1 = [];
var arr2 = [];
var arr3 = [];
var arr4 = [];

function predicate(el) {
    return el.tokenId.length === 0;
}

Tests:

foreach
contracts.forEach((element) => (element.tokenIds.length ? arr1.push(element) : arr2.push(element)));
reduce
contracts.reduce( (acc, element) => { acc[element.tokenIds.length ? 0 : 1].push(element); return acc; }, [[], []] );
two filters
arr3 = contracts.filter(f => f.tokenIds.length); arr4 = contracts.filter(f => !f.tokenIds.length);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach
reduce
two filters

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.

**Overview of the Benchmark**

The provided JSON represents a JavaScript benchmark that tests the performance of three different approaches to partition an array in a contract. The contracts are predefined arrays with varying lengths, and the goal is to compare the execution time of three methods: `forEach`, `reduce`, and two filter methods.

**Approaches Compared**

1. **`forEach`**: This method iterates over each element in the array and pushes it to an array if its token IDs length is zero.
2. **`reduce`**: This method reduces the array by applying a callback function to each element, which creates two new arrays based on whether the element's token ID length is zero or not.
3. **Two Filter Methods**:
	* `arr3 = contracts.filter(f => f.tokenIds.length);`: This method filters out elements with non-zero token IDs and pushes them to one array.
	* `arr4 = contracts.filter(f => !f.tokenIds.length);`: This method filters out elements with zero token IDs and pushes them to another array.

**Pros and Cons of Each Approach**

1. **`forEach`**:
	* Pros: Simple and easy to understand, good for small arrays.
	* Cons: Can be slow for large arrays due to the overhead of function calls and pushing elements to an array.
2. **`reduce`**:
	* Pros: Efficient for large arrays, as it reduces the number of iterations required.
	* Cons: Can be more complex to understand, especially for those without experience with reduce() method.
3. **Two Filter Methods**:
	* Pros: Can be efficient for filtering out elements based on a condition, reducing the amount of data to process.
	* Cons: May require additional memory to store the filtered arrays.

**Library and Special JS Features**

The benchmark uses the `filter()` method from the Array prototype, which is a built-in JavaScript library. There are no special JS features or syntax used in this benchmark.

**Other Considerations**

1. **Array partitioning**: The benchmark specifically tests array partitioning techniques, which can be useful in various contexts, such as data processing, machine learning, or blockchain applications.
2. **Microbenchmarking**: This benchmark is designed to measure the performance of small code snippets, known as microbenchmarks, which are typically used to compare the performance of different algorithms or implementations.

**Alternatives**

Other alternatives for array partitioning include:

1. `Array.prototype.map()`: While not exactly the same as filtering and pushing elements to an array, map() can be used in combination with other methods (e.g., filter(), push()) to achieve similar results.
2. **Custom implementation**: Depending on the specific requirements, a custom implementation of array partitioning could be more efficient or optimal.

In summary, this benchmark provides a clear comparison of three approaches for array partitioning in JavaScript, highlighting the pros and cons of each method.

Related benchmarks:

array partition (version: 0)

Comparing performance of: foreach vs reduce vs two filters

Created: 3 years ago by: Guest

Jump to the latest result

foreach

reduce

two filters

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