Benchmark: Naive some vs using pop shortening vs len trim

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; }) );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
naive compare
compare with pop
len trimming

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.7 Ops/sec
compare with pop	8.5 Ops/sec
len trimming	8.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to filtering arrays in JavaScript can be a useful exercise.

The benchmark defines three test cases: `naive compare`, `compare with pop`, and `len trimming`. The tests aim to measure the performance of each approach on an array of 20,000 objects.

**Options Compared:**

1. **Naive Compare**: This approach uses the `filter()` method with a callback function that checks for equality between elements.
2. **Compare with Pop**: This approach modifies the original `ignored` array by popping and assigning it to the matched element in the `watched` array, effectively "shortening" the array.
3. **Len Trimming**: This approach uses array indexing to access the last element of the `ignored` array and assigns it to the matched element in the `watched` array.

**Pros and Cons:**

1. **Naive Compare**:
	* Easy to understand and implement.
	* Works for small arrays, but can be slow for large ones due to the overhead of `filter()` and callback function execution.
2. **Compare with Pop**:
	* Can be faster than naive compare for large arrays because it modifies the original array, reducing the number of elements that need to be processed.
	* However, modifying the array can have performance implications if the array is not properly synchronized or managed.
3. **Len Trimming**:
	* More efficient than naive compare and compare with pop because it reduces the number of elements that need to be accessed in the `ignored` array.
	* However, this approach requires manual indexing and can lead to errors if the indices are not calculated correctly.

**Libraries Used:**

None of the test cases use any external libraries. The `filter()` method is a built-in JavaScript function.

**Special JS Features/Syntax:**

None of the test cases use special JavaScript features or syntax.

**Considerations:**

* When working with large arrays, consider using approaches that modify the original array to reduce overhead.
* Ensure proper synchronization and management when modifying arrays in performance-critical code.
* Manual indexing can lead to errors; consider using more robust data structures if performance is critical.

**Alternatives:**

If you're looking for alternative approaches to filtering arrays, consider:

1. Using `Array.prototype.filter()` with a regular expression (regex) pattern for fast and efficient filtering.
2. Employing techniques like "bucketing" or "hashing" to categorize elements into smaller groups before filtering.
3. Leveraging modern JavaScript features like `Set` or `Map` data structures for fast lookups.

These alternatives may offer better performance or readability, depending on your specific use case and requirements.

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

naive compare

compare with pop

len trimming

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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