Benchmark: Find item in array - Fork

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.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');
Lodash find index
var found = _.findIndex(selected, m => m.id === '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
Lodash find index

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of different methods for searching an item in an array. The test cases are designed to compare the execution speed of native JavaScript methods (`some`, `find`, and `findIndex`) with their Lodash counterparts.

**Native Methods**

1. `some`: Returns `true` if at least one element in the array satisfies the provided condition.
2. `find`: Returns the first element that satisfies the provided condition, or `-1` if no such element is found.
3. `findIndex`: Returns the index of the first element that satisfies the provided condition, or `-1` if no such element is found.

**Lodash Methods**

1. `_.some()`: Similar to native `some`, but uses Lodash's optimized implementation.
2. `_.find()`: Similar to native `find`, but uses Lodash's optimized implementation.
3. `_.findIndex()`: Similar to native `findIndex`, but uses Lodash's optimized implementation.

**Comparison of Methods**

The pros and cons of each method are as follows:

1. **Native `some`**:
	* Pros: Lightweight, fast, and efficient for simple use cases.
	* Cons: May be slower than other methods when dealing with large arrays or complex conditions.
2. **Lodash `.some()`**:
	* Pros: Optimized implementation, potentially faster than native `some`.
	* Cons: Adds an extra dependency (Lodash) and may not provide significant performance benefits for simple use cases.
3. **Native `find`**:
	* Pros: Returns the actual found element, which can be useful in certain scenarios.
	* Cons: May be slower than other methods when dealing with large arrays or complex conditions.
4. **Lodash `.find()`**:
	* Pros: Optimized implementation, potentially faster than native `find`.
	* Cons: Adds an extra dependency (Lodash) and may not provide significant performance benefits for simple use cases.
5. **Native `findIndex`**:
	* Pros: Returns the actual index of the found element, which can be useful in certain scenarios.
	* Cons: May be slower than other methods when dealing with large arrays or complex conditions.
6. **Lodash `.findIndex()`**:
	* Pros: Optimized implementation, potentially faster than native `findIndex`.
	* Cons: Adds an extra dependency (Lodash) and may not provide significant performance benefits for simple use cases.

**Additional Considerations**

1. **Complexity**: The "Complex" test case uses multiple operations in a single line, which can make it harder to optimize and may not accurately represent real-world scenarios.
2. **Dependency on Lodash**: Using Lodash introduces an additional dependency that may not be necessary for all use cases.

**Other Alternatives**

1. **Built-in `Array.prototype.includes()`**: This method returns `true` if the array includes the specified value, but it's only available in ECMAScript 2019 and later versions.
2. **Native `Array.prototype.findIndex()` with `Array.prototype.some()`**: This combination can provide an alternative to Lodash's methods while avoiding the dependency on a third-party library.

In conclusion, the choice of method depends on the specific use case and performance requirements. For simple scenarios, native methods may be sufficient, while optimized implementations like Lodash's methods or built-in `Array.prototype.includes()` may offer better performance.

Latest run results:

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

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

Browser/OS: Chrome 77 on Linux

View result in a separate tab

Test name	Executions per second
Native find	11328206.0 Ops/sec
Lodash find	2054333.4 Ops/sec
Lodash some	2595023.5 Ops/sec
Native some	11346746.0 Ops/sec
Native find index	11345956.0 Ops/sec
Complex	5132002.5 Ops/sec
Lodash find index	2693133.0 Ops/sec

Related benchmarks:

Find item in array - Fork (version: 0)

Add Lodash _.findIndex(); testcase.

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

Created: 6 years ago by: Guest

Jump to the latest result

Native find

Lodash find

Lodash some

Native some

Native find index

Complex

Lodash find index

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):