Benchmark: filter by indices big

Script Preparation code:

var length = 10000;
var value = 2000;
var sublength = 15;
var list = Array.from({length: length}, () => Math.floor(Math.random() * value));
var indices = Array.from({length: sublength}, () => Math.floor(Math.random() * length));

Tests:

for push
var filtered = []; for (idx of indices) { filtered.push(list[idx]) }
reduce push
filtered = indices.reduce((res, idx) => { res.push(list[idx]); return res; }, []);
filter some
filtered = list.filter((item, idx) => { return indices.some((index) => index === idx); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for push
reduce push
filter some

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36

Browser/OS: Chrome 88 on Linux

View result in a separate tab

Test name	Executions per second
for push	100852.6 Ops/sec
reduce push	381763.8 Ops/sec
filter some	586.7 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark definition, which includes the script preparation code, HTML preparation code (none in this case), and individual test cases.

The goal of this benchmark is to measure the performance of three different approaches for filtering an array using indices: `for` loop with `push`, `reduce` method with `push`, and `filter` method with `some`.

**Options Compared**

There are three options compared:

1. **For Loop with Push**: This approach uses a traditional `for` loop to iterate over the indices and push elements from the original array into a new filtered array.
2. **Reduce Method with Push**: This approach uses the `reduce` method to accumulate elements from the original array into a new filtered array, while also pushing them onto an accumulator array.
3. **Filter Method with Some**: This approach uses the `filter` method to create a new array containing only the elements that pass a test implemented by a provided function (in this case, checking if the index is present in the `indices` array).

**Pros and Cons**

1. **For Loop with Push**:
	* Pros: straightforward, easy to understand, and can be optimized for specific use cases.
	* Cons: may have higher overhead due to the need to create a new array and iterate over indices manually.
2. **Reduce Method with Push**:
	* Pros: concise, efficient, and can handle large datasets by accumulating elements in memory.
	* Cons: requires familiarity with the `reduce` method and its accumulator parameter.
3. **Filter Method with Some**:
	* Pros: concise, easy to read, and leverages existing array methods for filtering.
	* Cons: may have performance overhead due to the need to iterate over indices using `some()`.

**Library and Special JS Features**

None of the options rely on external libraries or special JavaScript features beyond the standard array methods and built-in functions.

**Considerations**

When choosing an approach, consider the following:

* Performance: Reduce method with push might be faster for large datasets due to its ability to accumulate elements in memory.
* Readability: Filter method with some is generally considered more readable, as it clearly conveys the intent of filtering based on indices.
* Optimizations: For Loop with Push can be optimized for specific use cases, such as caching intermediate results or using SIMD instructions.

**Alternatives**

If you're interested in exploring alternative approaches, consider:

1. **Array.prototype.map()**: This method creates a new array with elements transformed by applying a provided function to each element.
2. **Set data structure**: Using sets to store unique indices and filter elements based on their presence can be an efficient approach for filtering arrays.
3. **Native Web APIs**: Depending on the specific use case, native web APIs like `WebAssembly` or `Web Workers` might offer optimized performance improvements.

Keep in mind that these alternatives may require significant changes to the benchmark definition and test cases.

Related benchmarks:

filter by indices big (version: 0)

Comparing performance of: for push vs reduce push vs filter some

Created: 3 years ago by: Guest

Jump to the latest result

for push

reduce push

filter some

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