Benchmark: intersect v2c - MeasureThat.net

Script Preparation code:

Array.prototype.shuffle = function() {
  let m = this.length, i;
  while (m) {
    i = (Math.random() * m--) >>> 0;
    [this[m], this[i]] = [this[i], this[m]]
  }
  return this;
};

var watched = [];
for(let i = 0; i < 100000; i++){watched.push({programId:Math.random()});}

var ignored = [...watched];
ignored.shuffle();
ignored = ignored.slice(50000, 59000);

Tests:

some
watched.filter(wObj => { return !ignored.some((iObj, ndx) => iObj.programId === wObj.programId); });
some; pop and swap
watched.filter(wObj => !ignored.some((iObj, ndx) => { if (iObj.programId === wObj.programId) { ignored[ndx].programId = ignored.pop().programId; return true; } return false; }) );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
some
some; pop and swap

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
some	0.8 Ops/sec
some; pop and swap	191.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks. The provided benchmark definition json represents an example of a benchmark, while the individual test cases are also provided.

The main goal of this benchmark is to compare two approaches for filtering an array of objects based on certain conditions.

**Script Preparation Code**

The script preparation code is used to prepare the environment for the benchmark. In this case:

*   `Array.prototype.shuffle = function() {...}`: This line defines a custom method for shuffling arrays. Shuffling is a process that randomizes the order of elements in an array. The purpose of this method is likely to randomize the order of the ignored objects, making it harder for browsers to predict their behavior.
*   `var watched = [...];`: An array of 100,000 objects is created with randomly generated `programId` values.
*   `var ignored = [...watched];`: A copy of the `watched` array is created and shuffled using the custom method. The resulting `ignored` array contains 50,000 objects.
*   `ignored = ignored.slice(50000, 59000);`: A subset of 40,000 elements from the `ignored` array is extracted.

**Html Preparation Code**

The html preparation code is used to prepare the HTML environment for the benchmark. In this case, it's empty.

**Individual Test Cases**

There are two individual test cases:

1.  **"some"`**:
    *   This test case uses the original `filter()` method without modifying the ignored array.
    *   The purpose of this test case is likely to measure the performance of filtering an array using a simple condition.
2.  **"some; pop and swap"`**:
    *   This test case modifies the ignored array by swapping elements based on the programId values.
    *   The purpose of this test case is likely to measure the performance of filtering an array while modifying its contents.

**Pros and Cons**

The two approaches have different pros and cons:

1.  **"some"`**:
    *   Pros: Easy to understand, simple condition, and no modifications to the ignored array.
    *   Cons: May not be representative of real-world scenarios where filtering is used with modifications.
2.  **"some; pop and swap"`**:
    *   Pros: More realistic scenario for real-world use cases, but may require more complex code and understanding of array manipulation.
    *   Cons: May have performance overhead due to the array modification.

**Library Usage**

There is no explicit library usage in this benchmark definition. However, it's worth noting that some JavaScript engines might optimize or interpret certain syntax or features differently than others.

**Special JS Features**

There are no special JavaScript features or syntax used in this benchmark definition.

**Alternatives**

Some possible alternatives for similar benchmarks could be:

*   Using a different data structure, such as a linked list or a tree, instead of an array.
*   Adding more complex filtering conditions or requirements.
*   Measuring the performance of different algorithms for filtering and sorting arrays.

Keep in mind that these alternatives would require modifications to the benchmark definition and may not provide comparable results.

Related benchmarks:

intersect v2c (version: 0)

Comparing performance of: some vs some; pop and swap

Created: one year ago by: Guest

Jump to the latest result

some

some; pop and swap

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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