Benchmark: Distinct - MeasureThat.net

Script Preparation code:

var myArray = ['a', 1, 'a', 2, '1'];

function onlyUnique(value, index, self) {
  return self.indexOf(value) === index;
}

Tests:

ECMAScript 5
// usage example: var unique = myArray.filter(onlyUnique).length;
With ES6 it
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i).length;
ES6 has a native object Set to
let unique = new Set(myArray).size;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ECMAScript 5
With ES6 it
ES6 has a native object Set to

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition JSON**

The provided benchmark definition represents a JavaScript function that filters an array to only include unique values. The `onlyUnique` function uses the `indexOf` method to check if a value already exists in the array.

Here's a breakdown of the options compared:

1. **Using `indexOf`**: This approach uses the `indexOf` method, which searches for the first occurrence of a value in the array.
2. **Using an arrow function with `indexOf`**: This approach is similar to the previous one but uses an arrow function to define the callback function.
3. **Using the `Set` object**: This approach uses the `Set` object, which provides a built-in way to store unique values.

**Pros and Cons**

1. **Using `indexOf`**:
	* Pros: Easy to implement and widely supported.
	* Cons: Can be slow for large arrays due to the linear search algorithm.
2. **Using an arrow function with `indexOf`**:
	* Pros: Similar performance to the previous approach but with a slightly more concise syntax.
	* Cons: Still uses the `indexOf` method, which can lead to slow performance for large arrays.
3. **Using the `Set` object**:
	* Pros: Fast and efficient way to store unique values, with an average time complexity of O(1).
	* Cons: Requires a modern JavaScript environment that supports the `Set` object.

**Library and Special JS Features**

In this benchmark, no libraries are used. However, it's worth noting that some of the approaches might rely on internal implementation details or assumptions about the array data structure. For example, using `indexOf` assumes that the array is modified in place, which might not be the case for all arrays.

**Special JS Feature**

The arrow function syntax (`=>`) is a special JavaScript feature introduced in ECMAScript 2015 (ES6). It allows for concise and expressive function definitions without the need for explicit function declarations or `function` keywords. This feature is commonly used in modern JavaScript code to simplify function definitions and improve readability.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

1. **Using `Map` instead of `Set`**: While `Map` provides similar functionality to `Set`, it's more suitable for storing key-value pairs rather than just unique values.
2. **Using a custom implementation with bitwise operations**: It's possible to implement a custom algorithm that uses bitwise operations to check for uniqueness, which could potentially be faster than the other approaches.
3. **Using a Just-In-Time (JIT) compiler**: Modern JavaScript engines like V8 (used in Chrome) and SpiderMonkey (used in Firefox) include JIT compilers that can optimize the code for specific use cases.

Keep in mind that these alternatives might not be supported by all browsers or environments, so it's essential to consider the target audience and requirements when choosing an approach.

Latest run results:

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

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

Browser/OS: Chrome 103 on Windows

View result in a separate tab

Test name	Executions per second
ECMAScript 5	3824993.8 Ops/sec
With ES6 it	8068294.0 Ops/sec
ES6 has a native object Set to	3513804.5 Ops/sec

Related benchmarks:

Distinct (version: 0)

Comparing performance of: ECMAScript 5 vs With ES6 it vs ES6 has a native object Set to

Created: 3 years ago by: Registered User

Jump to the latest result

ECMAScript 5

With ES6 it

ES6 has a native object Set to

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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