Benchmark: Comparisons of performance for finding a value in an array

HTML Preparation code:

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

Script Preparation code:

var lodash = _.noConflict();
var underscore = _.noConflict();
var array = [...Array(100000).keys()];
var key = 90000;

Tests:

Array.Prototype.find
const value = array.find(x => x === key);
Array.Prototype.findIndex
const idx = array.findIndex(x => x === key); const value = array[idx]
For loop
let value; for (let i = 0; i < array.length; i++) { if (array[i] === key) { value = array[i]; break; } }
LoDash
const value = lodash.find(array, x => x === key);
Underscore
const value = underscore.find(array, x => x === key);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.Prototype.find
Array.Prototype.findIndex
For loop
LoDash
Underscore

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Array.Prototype.find	255.1 Ops/sec
Array.Prototype.findIndex	248.1 Ops/sec
For loop	86.8 Ops/sec
LoDash	263.1 Ops/sec
Underscore	240.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explore what's being tested.

**Benchmark Overview**

The benchmark compares four different methods for finding an item in an array: `Array.prototype.find`, `Array.prototype.findIndex`, a simple loop, Lodash (`lodash`), and Underscore (`underscore`). The test creates an array of 100,000 keys (from 0 to 99,999) and searches for a specific key value.

**Options Compared**

1. **Array.prototype.find**: This method returns the first element in the array that satisfies the provided testing function.
2. **Array.prototype.findIndex**: This method returns the index of the first element in the array that satisfies the provided testing function.
3. **For loop**: A simple iterative approach to find the desired key value by iterating through each element in the array.
4. **Lodash (`lodash`)**: The `find` function from Lodash is used to achieve similar results as Array.prototype.find.
5. **Underscore (`underscore`)**: The `find` function from Underscore is used to achieve similar results as Array.prototype.find.

**Pros and Cons of Each Approach**

1. **Array.prototype.find**: Fast, but only returns the first matching element. It's a built-in method, so it might have some overhead.
2. **Array.prototype.findIndex**: Similar to find, but returns an index instead of the value. It's also a built-in method with potential overhead.
3. **For loop**: Simple and straightforward, but slow due to its iterative nature.
4. **Lodash (`lodash`)**: Fast and efficient, but requires additional library overhead. The `noConflict()` function is used to avoid conflicts with existing global variables.
5. **Underscore (`underscore`)**: Similar to Lodash, fast and efficient, but also requires additional library overhead.

**Library and Syntax**

* **Lodash**: A popular utility library that provides a lot of functionality under the hood. The `find` function is a key part of it. It's designed for functional programming and is often used in JavaScript development.
* **Underscore**: Another utility library that provides similar functionality to Lodash. It's also designed for functional programming and has a small footprint.

**Special JS Features/Syntax**

None mentioned explicitly, but note that the use of `_.noConflict()` and `_` (the underscore symbol) is related to how these libraries are imported in a way to avoid conflicts with existing global variables.

**Other Alternatives**

For larger arrays or more complex searches, other approaches might be necessary. Some alternatives include:

* Using a data structure like a binary search tree or a hash table to improve lookup efficiency.
* Utilizing SIMD (Single Instruction, Multiple Data) instructions for parallel processing on modern CPUs.
* Leveraging the browser's built-in WebAssembly support for optimized performance.

Keep in mind that these alternatives might not be applicable depending on the specific requirements and constraints of your project.

Related benchmarks:

Comparisons of performance for finding a value in an array (version: 0)

Comparing several different methods for finding an item in an array (assuming complex objects)

Comparing performance of: Array.Prototype.find vs Array.Prototype.findIndex vs For loop vs LoDash vs Underscore

Created: 4 years ago by: Guest

Jump to the latest result

Array.Prototype.find

Array.Prototype.findIndex

For loop

LoDash

Underscore

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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