Benchmark: lodash includes vs includes vs indexof bydget

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Script Preparation code:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Tests:

lodash includes
_.includes(a, 16)
indexof
a.indexOf(16) !== -1
ECMA 7 includes
a.includes(16)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash includes
indexof
ECMA 7 includes

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Windows

View result in a separate tab

Test name	Executions per second
lodash includes	14076346.0 Ops/sec
indexof	29572224.0 Ops/sec
ECMA 7 includes	27326270.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 days ago):

LLMs can make mistakes. Check important info.

The benchmark presented in the provided JSON compares three different methods for checking if a value is present in an array in JavaScript. Each method has its own characteristics, and the test results show how they performed in terms of execution speed. Let’s break down the benchmark and discuss the pros and cons of each approach.

### Benchmark Overview

1. **Method: Lodash `_.includes`**
   - **Benchmark Definition:** `_.includes(a, 16)`
   - **Test Name:** lodash includes
   - **Library Used:** Lodash
     - **Purpose:** Lodash is a popular utility library in JavaScript that provides a variety of functions for common programming tasks such as array manipulation, object handling, and function manipulation. In this case, `_.includes` checks if the array contains a specific value.
   - **Execution Result:** 14,076,346 executions per second.

2. **Method: Array `indexOf`**
   - **Benchmark Definition:** `a.indexOf(16) !== -1`
   - **Test Name:** indexof
   - **Pros:** 
     - This method is well-supported across all JavaScript environments and is likely to be the most straightforward and efficient for this specific task.
     - Uses native JavaScript functionality, typically leading to faster execution compared to many library functions because it avoids the overhead of additional function calls.
   - **Cons:** 
     - Returns `-1` when the value is not found, which requires an additional comparison to check if the return value is not `-1`.
   - **Execution Result:** 29,572,224 executions per second.

3. **Method: Array `includes`**
   - **Benchmark Definition:** `a.includes(16)`
   - **Test Name:** ECMA 7 includes
   - **Pros:** 
     - This is a more modern approach (introduced in ECMAScript 2015, also known as ES6) that simply returns a boolean indicating the presence of the value, making it cleaner and more readable than `indexOf`.
   - **Cons:** 
     - It may have slightly more overhead compared to `indexOf`, as it is a newer method, and performance might not match that of the native `indexOf` in all situations.
   - **Execution Result:** 27,326,270 executions per second.

### Summary of Performance Results

In this benchmark:
- **`indexOf`** is the fastest method, demonstrating that using built-in JavaScript functions can often provide the best performance for common tasks.
- **`includes`** is slightly slower than `indexOf`, but its readability makes it a good choice in many situations where code clarity is more important than raw performance.
- **`lodash includes`** is the slowest, likely due to the overhead introduced by using a library function, which typically involves more substantial processing internally.

### Other Considerations

- **Readability vs. Performance:** While performance metrics are critical for applications dealing with large datasets or high-frequency operations, programmers should weigh readability and maintainability against performance, especially for less computationally intensive scenarios.
- **Compatibility:** All methods discussed are widely supported, but using the latest features like `Array.includes` may require transpilation for compatibility with older environments (such as ES5).
- **Library Dependency:** Utilizing libraries like Lodash can be advantageous for complex data manipulations. However, for simple operations like checking for an element's existence, native methods are often preferred.

### Alternatives

Apart from the methods tested:
- **Set Data Structure:** If the dataset is highly dynamic and performance is crucial, consider using a `Set` for O(1) average-time complexity in lookups instead of arrays. Lookups with `Set.has(value)` can outperform all discussed methods when checking membership.
- Other libraries such as **Ramda** or native utility functions may provide similar functionality but should be weighed against context-specific requirements, project size, and team proficiency with external libraries.

By understanding these methods and their implications, software engineers can make better choices that align with their application's requirements.

Related benchmarks:

lodash includes vs includes vs indexof bydget (version: 1)

Comparing performance of: lodash includes vs indexof vs ECMA 7 includes

Created: 9 days ago by: Guest

Jump to the latest result

lodash includes

indexof

ECMA 7 includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 days ago):