Benchmark: Array join and let unique values in return v2

Script Preparation code:

var a1 = [...Array(10000)].map((x, i) => ["Vijendra", "Singh", "ab", "cd", "ef", "gh", "ij", "kl", "mn", "op"][i % 10]);
var a2 = [...Array(10000)].map((x, i) => ["Singh", "Shakya", "ab", "cd", "zz", "xx", "ij", "kl", "AA", "BB"][i % 10]);
function K(arr1,arr2) {
  let r=[], h={};
  
  while(arr1.length) {
    let e = arr1.shift();
    if(!h[e]) h[e]=1 && r.push(e);
  }
  
  while(arr2.length) {
    let e = arr2.shift();
    if(!h[e]) h[e]=1 && r.push(e);
  }
  
  return r;
}

Tests:

c
return new Set([...a1,...a2]);
D
c=a1.concat(a2); return c.filter((item, pos) => c.indexOf(item) === pos);
E
return K(a1,a2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
c
D
E

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark on MeasureThat.net, which compares different approaches to remove duplicate values from two arrays.

**Benchmark Definition**

The benchmark is defined by three test cases:

1. `return new Set([...a1,...a2]);`: This approach uses the built-in `Set` data structure in JavaScript to eliminate duplicates.
2. `c=a1.concat(a2); return c.filter((item, pos) => c.indexOf(item) === pos);`: This approach uses the `concat()` method to concatenate the two arrays and then filters out duplicate values using an arrow function.
3. `return K(a1,a2);`: This approach defines a custom function `K` that takes two arrays as input and returns an array with unique values.

**Options Compared**

The benchmark compares three different approaches:

* Using `Set` to eliminate duplicates
* Using `concat()` and filtering to eliminate duplicates
* Defining a custom function `K` to eliminate duplicates

**Pros and Cons of Each Approach**

1. **Using `Set`**:
	* Pros: Efficient, concise, and easy to understand.
	* Cons: May not be suitable for very large arrays due to memory constraints, and some browsers may have issues with `Set` performance.
2. **Using `concat()` and filtering**:
	* Pros: Can handle large arrays, but may be slower than using `Set`.
	* Cons: More verbose and complex, with additional overhead from concatenating arrays and searching for duplicates.
3. **Defining a custom function `K`**:
	* Pros: Allows for fine-grained control over the elimination of duplicates.
	* Cons: More complex to implement, may require more memory, and may have performance issues due to the custom function.

**Library Used**

The benchmark uses the built-in `Set` data structure in JavaScript, which is a part of the standard library.

**Special JS Feature or Syntax**

There are no special JS features or syntax used in this benchmark. The code is straightforward and easy to understand.

**Other Alternatives**

Other alternatives for eliminating duplicates in arrays include:

* Using a `Map` data structure instead of `Set`
* Using an object with unique keys
* Using a custom implementation with manual iteration over the array
* Using a third-party library like Lodash or Underscore.js

However, using `Set` is often the most efficient and concise way to eliminate duplicates in modern JavaScript.

**Benchmark Result**

The latest benchmark result shows that the approach using `Set` (Test Name: "E") performs best with an execution rate of 5118944.5 executions per second. The approach using `concat()` and filtering (Test Name: "D") performs slower, with an execution rate of 458.4192810058594 executions per second. The custom function implementation (Test Name: "C") performs the slowest, with an execution rate of 6.702840805053711 executions per second.

Related benchmarks:

Array join and let unique values in return v2 (version: 0)

Comparing performance of: c vs D vs E

Created: 5 years ago by: Guest

Jump to the latest result

c

D

E

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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