Benchmark: Find item in array

HTML Preparation code:

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

Script Preparation code:

var selected = [{ id: '1' }, { id: '2' }, { id: '3' }];

Tests:

Native find
var found = selected.find(m => m.id === '3');
Lodash find
var found = _.find(selected, m => m.id === '3');
Lodash some
var found = _.some(selected, m => m.id === '3')
Native some
var found = selected.some(m => m.id === '3')
Native find index
var found = selected.findIndex(m => m.id === '3')
Complex
var indexes = selected.map(s => s.id); var found = selected.includes('3');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native find
Lodash find
Lodash some
Native some
Native find index
Complex

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 break down the provided JSON data and explain what's being tested.

**Benchmark Definition**

The `Script Preparation Code` section provides a JavaScript array `selected` containing three objects with an `id` property. The `Html Preparation Code` section includes a reference to the Lodash library, which will be used in some of the benchmark test cases.

**Test Cases**

There are six test cases:

1. **Native find**: This test case uses the built-in `find()` method on the `selected` array, searching for an object with an `id` equal to '3'.
2. **Lodash find**: This test case uses the `_find()` function from Lodash, passing the same search criteria as in the native implementation.
3. **Lodash some**: This test case uses the `_some()` function from Lodash, searching for at least one object with an `id` equal to '3'.
4. **Native some**: This test case uses the built-in `some()` method on the `selected` array, similar to the previous native implementation.
5. **Native find index**: This test case uses the `_findIndex()` function, which returns the index of the first element that satisfies the condition.
6. **Complex**: This test case is a bit more complex and involves multiple operations:
	* It maps each object in `selected` to its `id`.
	* Then, it searches for an occurrence of '3' in the array using `includes()`. While not directly related to finding an element by value, this operation can provide insight into how Lodash's implementation compares.

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides various helper functions. In this benchmark, `_find()` and `_some()` are used to compare their performance with the native implementations.

**Pros and Cons of Different Approaches**

Here's a brief summary:

* **Native find**: This approach is often implemented as a single function call, which can be optimized for performance.
	+ Pros: Typically faster due to caching and reduced overhead.
	+ Cons: May not support all possible search criteria (e.g., arrays with non-numeric keys).
* **Lodash find**:
	+ Pros: More flexible search criteria, including support for arrays with non-numeric keys. Lodash can also optimize performance in some cases.
	+ Cons: Adds an external dependency and may incur a slight overhead due to function call and argument passing.
* **Native some**: Similar to `find()`, but only returns when at least one element satisfies the condition.
	+ Pros: Generally faster than `_some()` due to reduced overhead.
	+ Cons: May not be as flexible as Lodash's implementation.
* **Lodash some**:
	+ Pros: More flexible search criteria and can handle arrays with non-numeric keys.
	+ Cons: Typically slower than native implementations due to function call and argument passing.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark. The focus is on comparing the performance of different approaches, without introducing any additional complexity that might skew the results.

**Other Alternatives**

If you're interested in exploring other options, consider the following:

* **Underscore.js**: Similar to Lodash, but with a slightly different API and set of features.
* **Array.prototype.findIndex()` (ES6+): A built-in method for finding the index of the first element that satisfies the condition. However, this implementation may not be as efficient as native implementations.
* **Manual loop-based implementation**: You can also implement your own search function using a loop to iterate over the array elements. This approach would lack optimization and flexibility compared to native or library-based implementations.

Keep in mind that these alternatives might affect the results of the benchmark, so it's essential to consider the specific requirements and constraints of your project when choosing an implementation.

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
Native find	12963448.0 Ops/sec
Lodash find	4153650.0 Ops/sec
Lodash some	3879398.5 Ops/sec
Native some	11934418.0 Ops/sec
Native find index	12055631.0 Ops/sec
Complex	6026533.0 Ops/sec

Related benchmarks:

Find item in array (version: 0)

Comparing performance of: Native find vs Lodash find vs Lodash some vs Native some vs Native find index vs Complex

Created: 6 years ago by: Guest

Jump to the latest result

Native find

Lodash find

Lodash some

Native some

Native find index

Complex

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