Benchmark: IndexOf vs Includes vs lodash includes vs for

Script Preparation code:

var array = ['banana', 'sausage', 'jesus']

Tests:

indexOf
array.indexOf('sausage') !== 1
includes
array.includes('sausage')
lodash
_.includes(array, 'sausage')
for
const inArray = (target = 'sausage', array) => { for(var i = 0; i < array.length; i++) { if(array[i] === target) { return true; } } return false; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
includes
lodash
for

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
indexOf	10817521.0 Ops/sec
includes	11842122.0 Ops/sec
lodash	3254000.5 Ops/sec
for	964807488.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark definition and test cases to explain what's being tested, the pros and cons of different approaches, and other considerations.

**Benchmark Definition JSON**

The benchmark definition represents a series of tests designed to compare the performance of four different methods for searching an array:

1. `indexOf`: The built-in JavaScript method for finding the index of a specific value in an array.
2. `includes`: A newer built-in JavaScript method (introduced in ES6) for checking if a value is present in an array.
3. `lodash includes` : A custom implementation using the `_includes` function from the Lodash library, which provides various utility functions for working with arrays and objects.
4. `for`: A custom implementation using a simple loop to iterate through the array elements.

**Test Cases**

Each test case represents one of the four methods being tested:

1. **indexOf**: Tests the built-in `indexOf` method with a specific value ("sausage") in an example array.
2. **includes**: Tests the built-in `includes` method with the same value as above.
3. **lodash includes**: Tests the `_includes` function from Lodash, also with the same value as above.
4. **for**: Tests the custom implementation using a loop to find the target value in the array.

**What's being tested?**

Each test case is designed to measure the performance of each method:

* `indexOf`, `includes`, and `_includes` are testing the efficiency of these built-in methods for searching arrays.
* The `for` implementation is testing the performance of a custom loop-based approach.

**Pros and Cons of different approaches:**

1. **Built-in methods (indexOf, includes)**:
	* Pros:
		+ Fast and efficient, optimized by the JavaScript engine.
		+ Simple and concise code.
	+ Cons:
		- May have varying performance across different browsers and versions.
		- Not always suitable for large datasets or specific use cases.
2. **Lodash `_includes`**:
	* Pros:
		+ Highly optimized and efficient implementation.
		+ Provides additional features and flexibility.
	* Cons:
		+ Requires including Lodash library in the project.
		- May have overhead due to importing an external library.
3. **Custom loop-based approach (for)**:
	* Pros:
		+ Can be highly optimized for specific use cases.
		+ Allows fine-grained control over iteration and indexing.
	* Cons:
		+ Can be slower and more verbose than built-in methods.
		- May require manual optimization and tuning.

**Other considerations:**

1. **Browser differences**: The benchmark results may vary across different browsers and versions due to differences in engine optimizations, caching, or memory management.
2. **Array size and complexity**: The performance of each method can be influenced by the size and complexity of the array being searched.
3. **Specific use cases**: Depending on the specific requirements of your application, you might prefer one method over another for its speed, simplicity, or features.

**Alternatives:**

If you're looking for alternatives to these methods, consider:

1. `Array.prototype.some()` or `Array.prototype.every()`: These methods can be used in combination with callback functions to achieve similar results.
2. Custom implementations using bitwise operations (e.g., `bitwise XOR`).
3. Using specialized libraries like FastJSON or JSON parsing libraries for efficient string search.

Keep in mind that the choice of method ultimately depends on your specific use case, performance requirements, and coding style preferences.

Related benchmarks:

IndexOf vs Includes vs lodash includes vs for (version: 0)

Comparing performance of: indexOf vs includes vs lodash vs for

Created: 3 years ago by: Guest

Jump to the latest result

indexOf

includes

lodash

for

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