Benchmark: lodah includes vs lodash

HTML Preparation code:

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

Script Preparation code:

var dailyActivity = { type: 'SetGoals' };

Tests:

lodash
(() => { return !_.isEmpty(dailyActivity); })()
lodash includes
(() => { return _.includes(['FirstSetGoals', 'SetGoals'], dailyActivity.type); })()
includes
(() => { return ['FirstSetGoals', 'SetGoals'].includes(dailyActivity.type); })()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
lodash includes
includes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on MeasureThat.net.

**Benchmark Overview**

The benchmark compares three approaches for checking if an element exists in an array:

1. Lodash's `_.includes()` method
2. A custom implementation using the `Array.prototype.includes()` method (native JavaScript)
3. Another custom implementation using a simple `if` statement

**Libraries and Their Purpose**

In this benchmark, two libraries are used:

1. **Lodash**: A popular utility library for JavaScript that provides a vast array of functions for tasks like array manipulation, object processing, and more.
2. **None**: The native JavaScript `Array.prototype.includes()` method is being compared to Lodash's implementation.

**Special JS Features or Syntax**

This benchmark doesn't rely on any special JavaScript features or syntax beyond the standard language features supported by most modern browsers.

**Benchmark Options Compared**

The three options being compared are:

1. **Lodash includes**: Uses Lodash's `_.includes()` method to check if an element exists in an array.
	* Pros:
		+ Generally faster than native JavaScript implementations due to optimization and caching.
		+ Provides a simple and concise API for common tasks like array manipulation.
	* Cons:
		+ Requires the inclusion of an external library (Lodash).
2. **Includes**: Uses the native JavaScript `Array.prototype.includes()` method to check if an element exists in an array.
	* Pros:
		+ No external dependencies required, making it a lightweight option.
		+ Faster than Lodash implementation for small arrays due to caching.
3. **Lodash**: Uses Lodash's implementation of the `includes` function without the `_.includes()` method.
	* Pros:
		+ Provides a performance similar to native JavaScript implementation for small arrays.
		+ No external dependencies required.

**Other Considerations**

When choosing between these options, consider the trade-offs:

* **Performance**: Native JavaScript implementations (e.g., `Array.prototype.includes()`) tend to be faster than Lodash's implementation due to caching and optimization. However, for smaller arrays or applications where Lodash is a necessary dependency, Lodash's performance can still be competitive.
* **Size and Complexity**: The size and complexity of the array being checked play a significant role in determining which option is faster. Small arrays are more likely to benefit from native JavaScript implementations, while larger arrays may favor Lodash's implementation due to its optimization and caching.

**Alternative Implementations**

If you're interested in exploring alternative implementations, consider:

1. **Splice-based Implementation**: Instead of using `Array.prototype.includes()`, you could implement a custom search function using the `splice()` method. This approach has better performance for small arrays but can be slower for larger ones.
2. **Binary Search Algorithm**: Implementing a binary search algorithm to find an element in an array can offer faster performance for large datasets.

In summary, this benchmark compares three approaches for checking if an element exists in an array: Lodash's `_.includes()` method, native JavaScript `Array.prototype.includes()`, and custom implementations. The choice of implementation depends on factors like performance requirements, size and complexity of the array, and desired level of dependencies (Lodash vs. none).

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/76.0.3809.132 Safari/537.36

Browser/OS: Chrome 76 on Linux

View result in a separate tab

Test name	Executions per second
lodash	1411012.2 Ops/sec
lodash includes	1634033.4 Ops/sec
includes	5292264.5 Ops/sec

Related benchmarks:

lodah includes vs lodash (version: 0)

lodash vs includes

Comparing performance of: lodash vs lodash includes vs includes

Created: 5 years ago by: Guest

Jump to the latest result

lodash

lodash includes

includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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