Benchmark: medium size array find object with certain properties

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.core.js"></script>

Script Preparation code:

  var media = {};
  const DATA_LENGTH = 4000;
  for (let i = 1; i <= DATA_LENGTH; i++) {
      media["c42dec10-6328-4ac1-97af-63ec8d8d302" + i] = {
          "mediumId": "c42dec10-6328-4ac1-97af-63ec8d8d302" + i,
          "cid": "1143200002A71",
          "uid": null,
          "active": true,
          "revoked": false,
          "personId": "0e3cf8c1-7a26-4335-9c7a-c133d218011" + i
      };
  }

Tests:

find lodash
_.find(Object.values(media), { personId:"0e3cf8c1-7a26-4335-9c7a-c133d2180112000", revoked: false })
for in
var found = null; for (let key in media) { if (media.hasOwnProperty(key)) { let value = media[key]; if (media[key].personId === "0e3cf8c1-7a26-4335-9c7a-c133d2180112000" && media[key].revoked === false) { found= media[key]; break; } } }
find native
Object.values(media).find(m => m.personId === "0e3cf8c1-7a26-4335-9c7a-c133d2180112000" && m.revoked === false)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
find lodash
for in
find native

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
find lodash	1486.6 Ops/sec
for in	1726.0 Ops/sec
find native	1700.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three approaches to find an object with specific properties in a medium-sized array:

1. **ES6 spread operator**: Using the `...` operator to create a new array from the existing one.
2. **Traditional `concat()` method**: Using the `concat()` method to concatenate arrays and then searching for the target object.
3. **Native `.find()` method with callback function**: Using the `.find()` method on the array, passing a callback function to filter the results.

**Options Compared**

The benchmark tests three different approaches:

* **ES6 spread operator**: This approach creates a new array from the existing one by using the `...` operator. The idea is that this approach might be faster than the traditional `concat()` method because it avoids creating a temporary array.
* **Traditional `concat()` method**: This approach concatenates the original array with an empty array, and then searches for the target object in the resulting array. This approach is more verbose but can be faster in some cases.
* **Native `.find()` method with callback function**: This approach uses the `.find()` method on the array, passing a callback function to filter the results. The idea is that this approach is likely to be the fastest because it's optimized for finding specific elements in an array.

**Pros and Cons**

Here are some pros and cons of each approach:

* **ES6 spread operator**:
	+ Pros: Creates a new array from the existing one, might be faster than traditional `concat()`.
	+ Cons: Can lead to performance issues with very large arrays because it creates a new array.
* **Traditional `concat()` method**:
	+ Pros: Might be faster for large arrays because it avoids creating a temporary array.
	+ Cons: Verbose and less readable, might not work correctly if the original array is modified while searching.
* **Native `.find()` method with callback function**:
	+ Pros: Optimized for finding specific elements in an array, likely to be the fastest.
	+ Cons: Limited control over the filtering process, might not work correctly if the array contains non-numeric indices.

**Library and Syntax**

The benchmark uses the `lodash` library, which provides a `find()` function that can be used to filter arrays. The syntax is simple and easy to read:

```javascript
_.find(media, { personId: '0e3cf8c1-7a26-4335-9c7a-c133d2180112000', revoked: false });
```

This code uses the `find()` function from `lodash` to search for an object with specific properties in the `media` array.

**Device and Browser Information**

The benchmark was run on a Chrome 114 browser, running on a Linux desktop platform. The results show that the native `.find()` method with callback function is the fastest approach, followed by the traditional `concat()` method, and then the ES6 spread operator.

**Other Alternatives**

If you're looking for alternative approaches to find an object in an array, here are some options:

* **Using a custom filtering function**: You can create a custom filtering function using an arrow function or a regular function. For example:
```javascript
const found = media.find(item => item.personId === '0e3cf8c1-7a26-4335-9c7a-c133d2180112000' && item.revoked === false);
```
* **Using `Array.prototype.some()`**: You can use the `some()` method to find an object that matches a condition. For example:
```javascript
const found = media.some(item => item.personId === '0e3cf8c1-7a26-4335-9c7a-c133d2180112000' && item.revoked === false);
```
Note that the `some()` method returns a boolean value indicating whether any element in the array matches the condition, rather than returning the matched object.

Overall, the benchmark highlights the importance of understanding the trade-offs between different approaches to finding an object in an array. While the native `.find()` method with callback function is likely to be the fastest approach, other methods like traditional `concat()` and custom filtering functions can still be effective depending on the specific use case.

Related benchmarks:

medium size array find object with certain properties (version: 0)

Compare the new ES6 spread operator with the traditional concat() method

Comparing performance of: find lodash vs for in vs find native

Created: one year ago by: Guest

Jump to the latest result

find lodash

for in

find native

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