Benchmark: Find diff two array

Tests:

indexOf
var first = [ 1, 2, 3, 4, 5 ]; var second = [ 4, 5, 6 ]; var difference = first.filter(x => second.indexOf(x) === -1); console.log(difference);
includes
var first = [ 1, 2, 3, 4, 5 ]; var second = [ 4, 5, 6 ]; var difference = first.filter(x => !second.includes(x)); console.log(difference); /* Output: [ 1, 2, 3] */
Set objec
var first = [ 1, 2, 3, 4, 5 ]; var second = [ 4, 5, 6 ]; var b = new Set(second); var difference = [...first].filter(x => !b.has(x)); console.log(difference);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
includes
Set objec

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the explanation into manageable parts.

**Benchmark Definition JSON**

The provided JSON represents a benchmark definition for measuring JavaScript performance. It contains three optional fields:

* `Name`: A descriptive name for the benchmark.
* `Description`: A brief description of the benchmark (empty in this case).
* `Script Preparation Code` and `Html Preparation Code`: Optional code to be executed before running the benchmark.

Since these fields are empty, no preparation code is being executed before running the benchmarks. The focus is on measuring the performance of the JavaScript microbenchmarks defined in the individual test cases.

**Individual Test Cases**

There are three test cases:

1. `indexOf`
2. `includes`
3. `Set object`

Each test case has a `Benchmark Definition` JSON that defines the code to be executed during the benchmark.

**Options Compared**

In each test case, two different approaches are compared:

* Approach 1: Using `indexOf` method
* Approach 2: Using `includes` method

**Pros and Cons of Each Approach**

Here's a brief analysis of each approach:

**Approach 1: `indexOf` Method**

Pros:

* Widely supported across browsers
* Simple to implement

Cons:

* Slow performance, especially for large arrays
* May cause unnecessary DOM searches (in the case of Chrome)

**Approach 2: `includes` Method**

Pros:

* Faster performance compared to `indexOf`
* More modern and efficient implementation

Cons:

* May not be supported in older browsers or versions
* Requires modern JavaScript features (ES6+)

**Set Object Approach (`Set object`)**

This approach uses a `Set` object to store unique elements from the second array. The filter function then checks if each element from the first array is present in the `Set`. This approach:

Pros:

* Fast performance, especially for large arrays
* Efficient implementation using `Set` data structure

Cons:

* Requires modern JavaScript features (ES6+)
* May not be supported in older browsers or versions

**Library: `includes` method**

The `includes` method is a built-in method in modern JavaScript (ES6+) that checks if an element is present in an array. It's implemented using the `Array.prototype.includes()` function.

**Special JS Feature/Syntax**

* `Set object`: Uses a `Set` data structure to store unique elements.
* Modern JavaScript features (ES6+): Requires support for `includes`, `Set`, and other modern syntaxes, such as template literals (`\r\n`) and arrow functions (`=>`).

**Other Alternatives**

If the `includes` method is not supported or desired, alternative approaches can be used:

* Using a manual loop to iterate through the second array
* Using a third-party library that provides similar functionality
* Employing other optimized algorithms, such as bitwise operations or caching

Keep in mind that these alternatives might have different performance characteristics and may require additional code or configuration.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
indexOf	154105.3 Ops/sec
includes	151465.3 Ops/sec
Set objec	142287.4 Ops/sec

Related benchmarks:

Find diff two array (version: 0)

Comparing performance of: indexOf vs includes vs Set objec

Created: 3 years ago by: Guest

Jump to the latest result

indexOf

includes

Set objec

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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