Benchmark: Duplicate Object[] Test

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js'></script>

Script Preparation code:

var array = [
  { 'name': '소나타', 'brand': '현대' },
  { 'name': '아반떼', 'brand': '현대' },
  { 'name': 'K7', 'brand': '기아' }
];

Tests:

Object.values / Object.assign
function func(array) { const result = Object.values(array.reduce((prev, cur) => Object.assign(prev, { [cur.brand]: cur }), {})); return result; } func(array);
filter
function func(array) { let uniq = {}; const result = array.filter(arr => !uniq[arr.brand] && (uniq[arr.brand] = true)); return result; } func(array);
filter / findIndex
function func(array) { const result = array.filter((arr, i) => array.findIndex((arr2) => arr['brand'] === arr2['brand']) === i); return result; } func(array);
for / includes
function func(array) { let tempArray = [], resultArray = []; for (let i = 0; i < array.length; i++) { let arr = array[i]; if (tempArray.includes(arr['brand'])) { continue; } else { resultArray.push(arr); tempArray.push(arr['brand']); } } return resultArray; } func(array);
underscore
function func(array) { const result = _.uniq(array, 'brand'); return result; } func(array);
reduce / some
function func(array) { const result = array.reduce((prev, cur) => { if (!prev.some(obj => obj['brand'] !== cur['brand'])) { prev.push(cur); } return prev; }, []); return result; } func(array);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values / Object.assign
filter
filter / findIndex
for / includes
underscore
reduce / some

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 benchmark and explain what is tested, the pros and cons of different approaches, and other considerations.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case called "Duplicate Object[] Test". The benchmark measures the performance of various approaches to remove duplicate objects from an array. There are four test cases:

1. `Object.values / Object.assign`
2. `filter`
3. `filter / findIndex`
4. `for / includes`
5. `underscore`
6. `reduce / some`

**Test Case 1: Object.values / Object.assign**

This test case uses the `Object.values` method to extract an array of object values and then uses `Object.assign` to merge these arrays into a single array with unique keys.

Pros:

* Efficient use of `Object.values`, which is faster than accessing individual properties.
* Uses `Object.assign`, which is a built-in method for merging objects.

Cons:

* Requires the use of `Object.values` and `Object.assign`, which may not be familiar to all developers.

**Test Case 2: filter**

This test case uses the `filter` method to remove duplicate objects from the array. The filtering condition checks if an object's brand is already present in a temporary array, and if so, the object is skipped.

Pros:

* Simple and intuitive implementation.
* Uses a familiar method (`filter`) that many developers are already familiar with.

Cons:

* May not be efficient for large arrays due to the use of a temporary array for filtering.

**Test Case 3: filter / findIndex**

This test case combines the `filter` method with the `findIndex` method to remove duplicate objects from the array. The filtering condition uses `findIndex` to check if an object's brand is already present in the array, and if so, the object is skipped.

Pros:

* Efficient use of `findIndex`, which can be faster than the `filter` method for large arrays.
* Uses a familiar method (`findIndex`) that many developers are already familiar with.

Cons:

* Requires the use of two methods (`filter` and `findIndex`) which may not be as straightforward to implement.

**Test Case 4: for / includes**

This test case uses a `for` loop to iterate over the array and checks if each object's brand is present in a temporary array using the `includes` method. If the brand is found, the object is skipped.

Pros:

* Uses a familiar method (`for`) that many developers are already familiar with.
* Can be efficient for small arrays due to the use of a simple loop.

Cons:

* May not be efficient for large arrays due to the use of a temporary array and multiple method calls.
* Requires careful handling of the `includes` method, which can be prone to errors if used incorrectly.

**Test Case 5: underscore**

This test case uses the `underscore` library to remove duplicate objects from the array. The implementation uses a combination of methods provided by `underscore`, including `_uniqBy`.

Pros:

* Uses a well-established and efficient library (underscore) that is widely adopted.
* Provides a convenient and readable implementation.

Cons:

* Requires the use of an external library (`underscore`), which may require additional setup or maintenance.

**Test Case 6: reduce / some**

This test case uses the `reduce` method to remove duplicate objects from the array. The reduction operation checks if each object's brand is already present in a temporary array using the `some` method, and if so, the object is skipped.

Pros:

* Efficient use of `reduce`, which can be faster than the `filter` or `for` methods for large arrays.
* Uses a familiar method (`reduce`) that many developers are already familiar with.

Cons:

* Requires careful handling of the `some` method, which can be prone to errors if used incorrectly.
* May not be as straightforward to implement as other test cases.

**Other Considerations**

* The benchmark uses Chrome 88 as the browser, but it's worth noting that performance may vary across different browsers and environments.
* The benchmark measures executions per second, which provides a good indication of performance but may not accurately reflect real-world usage scenarios.
* The use of `Object.values` and `Object.assign` in Test Case 1 may not be suitable for all developers or use cases.

In conclusion, each test case has its pros and cons, and the choice of implementation depends on the specific requirements and constraints of the project. By understanding the trade-offs and considerations involved in each approach, developers can make informed decisions about which method to use for their specific use case.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.96 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.1.0

View result in a separate tab

Test name	Executions per second
Object.values / Object.assign	712785.5 Ops/sec
filter	5618109.0 Ops/sec
filter / findIndex	10111002.0 Ops/sec
for / includes	8332516.5 Ops/sec
underscore	1947506.8 Ops/sec
reduce / some	10400034.0 Ops/sec

Related benchmarks:

Duplicate Object[] Test (version: 1)

Comparing performance of: Object.values / Object.assign vs filter vs filter / findIndex vs for / includes vs underscore vs reduce / some

Created: 4 years ago by: Registered User

Jump to the latest result

Object.values / Object.assign

filter

filter / findIndex

for / includes

underscore

reduce / some

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):