Benchmark: Naive some vs using pop shortening vs len trim vs for

Script Preparation code:

var watched = [];
var ignored = [];

for(let i = 0; i < 10000; i++){watched.push({programId:Math.random()});}
for(let i = 0; i < 10000; i++){ignored.push({programId:Math.random()});}

Tests:

naive compare
watched.filter(obj => { return !ignored.some(item => item.programId === obj.programId); });
compare with pop
watched.filter(wObj => !ignored.some((iObj, ndx) => { if (iObj.programId === wObj.programId) { ignored[ndx] = ignored.pop(); return true; } return false; }) );
len trimming
let ml = ignored.length -1; watched.filter(wObj => !ignored.some((iObj, ndx) => { if (iObj.programId === wObj.programId) { ignored[ndx] = ignored[ml]; ignored.length--; ml--; return true; } return false; }) );
for
let ml = ignored.length -1; watched.filter(wObj => { for (let i = 0; i < ml; i++) { if (wObj.programId === watched[i].programId) { watched[i] = watched[ml]; ml--; return false; } } return true; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
naive compare
compare with pop
len trimming
for

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
naive compare	11.9 Ops/sec
compare with pop	8.5 Ops/sec
len trimming	8.5 Ops/sec
for	1.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark measures the performance of different approaches to filter out elements in an array while preserving their original order. The test case creates two arrays, `watched` and `ignored`, each with 10,000 random program IDs. The goal is to write a function that filters out elements from `watched` based on their presence in `ignored`.

**Comparison Options**

There are four comparison options:

1. **Naive Compare**: Uses the `filter()` method without any optimizations.
2. **Compare with Pop**: Uses the `pop()` method to remove elements from `ignored` while filtering.
3. **Len Trimming**: Uses array indexing and length manipulation to trim elements from `watched`.
4. **For Loop**: Uses a for loop to iterate over the elements in `watched`.

**Pros and Cons**

1. **Naive Compare**:
	* Pros: Simple, easy to understand.
	* Cons: Inefficient, as it creates a new array with filtered elements.
2. **Compare with Pop**:
	* Pros: Efficient, as it modifies the original `ignored` array.
	* Cons: May cause issues if the arrays are large, as it can lead to stack overflow errors.
3. **Len Trimming**:
	* Pros: Efficient, as it minimizes the number of elements in `watched`.
	* Cons: Can be slower for small arrays due to the overhead of indexing and length manipulation.
4. **For Loop**:
	* Pros: Can be faster for small arrays due to caching effects.
	* Cons: Inefficient for large arrays, as it requires explicit iteration.

**Library Usage**

There is no specific library used in this benchmark, but `Array.prototype.filter()` is a built-in method that filters elements based on a provided callback function.

**Special JS Features or Syntax**

The benchmark uses the following features:

1. **Template literals**: Used for string interpolation in some test cases.
2. **Array indexing and length manipulation**: Used in the "Len Trimming" option to minimize the number of elements in `watched`.

**Other Alternatives**

If you're looking for alternative approaches, consider the following options:

1. **Spliced filtering**: Use `splice()` method instead of `filter()`, which can be more efficient but may cause issues with preserving original order.
2. **Array.prototype.findIndex()**: Use this method to find the index of an element in `watched` and then use that index to filter out elements from `ignored`.
3. **Using Set data structure**: Convert `ignored` to a Set for faster lookup, but be aware that Sets are not suitable for preserving original order.

These alternatives may offer different trade-offs between performance, code complexity, and ease of maintenance.

Related benchmarks:

Naive some vs using pop shortening vs len trim vs for (version: 0)

Comparing performance of: naive compare vs compare with pop vs len trimming vs for

Created: one year ago by: Guest

Jump to the latest result

naive compare

compare with pop

len trimming

for

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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