Benchmark: Array.find vs lodash _.includes vs compiled regex

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.core.js"></script>

Script Preparation code:

var strings = [
    'one', 'two', 'three'
]
var regex = /^(one|two|three)$/;

var input = 'three'

Tests:

array find
// Native !!strings.find(function (o) { return o == input; })
_.find
!!_.find(users, function (o) { return o==input; })
regex
regex.test(input)
regex (i)
regex.test(input)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
_.find
regex
regex (i)

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 break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark compares the performance of three different approaches to check if an element exists in an array or string:

1. Native JavaScript `Array.prototype.find()`
2. Lodash `_.find()` function
3. Compiled regular expression (`^` anchor with a regex pattern)

**Test Case 1: Array Find (Native)**

* **Benchmark Definition**: `!!strings.find(function (o) { return o == input; })`
* **Test Name**: "array find"
* **Library/Function Used**: Native JavaScript `Array.prototype.find()`

This test case uses the native JavaScript `find()` method to search for an element in the `strings` array. The callback function checks if the current element (`o`) is equal to the input string.

**Pros and Cons:**

Pros:

* Fastest execution time due to native optimization
* Minimal memory overhead

Cons:

* Only supported by browsers that implement `Array.prototype.find()`
* May not work as expected in older browsers or environments with limited JavaScript capabilities

**Test Case 2: _.find (Lodash)**

* **Benchmark Definition**: `!!_.find(users, function (o) { return o==input; })`
* **Test Name**: "_.find"
* **Library/Function Used**: Lodash `_.find()` function

This test case uses the Lodash `find()` function to search for an element in the `users` array. The callback function checks if the current element (`o`) is equal to the input string.

**Pros and Cons:**

Pros:

* Widely supported by browsers that support Lodash
* Can be used as a fallback when native JavaScript `find()` is not available

Cons:

* Slightly slower execution time compared to native `find()`
* Adds additional memory overhead due to the library

**Test Case 3: regex.test (Compiled)**

* **Benchmark Definition**: "regex.test(input)"
* **Test Name**: "regex"
* **Library/Function Used**: Compiled regular expression (`^` anchor with a regex pattern)

This test case uses a compiled regular expression to search for an element in the input string. The `^` anchor matches the start of the string, and the regex pattern is optimized for performance.

**Pros and Cons:**

Pros:

* Fastest execution time due to compiler optimization
* Minimal memory overhead

Cons:

* Limited support on older browsers or environments that don't support regular expressions
* May not work as expected if the input string contains special characters or edge cases

**Test Case 4: regex.test (Case-Insensitive)**

* **Benchmark Definition**: "regex.test(input)"
* **Test Name**: "regex (i)"
* **Library/Function Used**: Compiled regular expression (`^` anchor with a regex pattern)

This test case uses the same compiled regular expression as the previous test case, but adds the `(i)` flag to make the match case-insensitive.

**Pros and Cons:**

Pros:

* Provides a better match for inputs with varying case
* Slightly slower execution time compared to non-case-insensitive regex

Cons:

* May be slower than non-case-insensitive regex on some browsers or environments
* Adds additional complexity due to the case-insensitivity flag

In summary, the benchmark compares the performance of three different approaches to check if an element exists in an array or string. The native JavaScript `find()` method is generally the fastest but has limited support, while Lodash's `_find()` function provides a fallback solution but adds memory overhead. The compiled regular expression approach offers fast execution time and minimal memory overhead, but may not work on older browsers or environments that don't support regular expressions.

Other alternatives to consider:

* Using `Array.prototype.some()` instead of `find()`
* Using a different library like `Sprintf` or `String.prototype.includes()`
* Optimizing the regex pattern for specific use cases
* Considering alternative data structures, such as sets or maps, for faster lookups

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 16 on iOS 16.5.1

View result in a separate tab

Test name	Executions per second
array find	7071586.0 Ops/sec
_.find	0.0 Ops/sec
regex	12618056.0 Ops/sec
regex (i)	12069677.0 Ops/sec

Related benchmarks:

Array.find vs lodash _.includes vs compiled regex (version: 0)

Compare the new ES6 spread operator with the traditional concat() method

Comparing performance of: array find vs _.find vs regex vs regex (i)

Created: 4 years ago by: Guest

Jump to the latest result

array find

_.find

regex

regex (i)

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