Benchmark: native reverse findIndex vs lodash _.findLastIndex

HTML Preparation code:

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

Script Preparation code:

var users = [
  { 'user': 'joey',  'age': 32 },
  { 'user': 'ross',    'age': 41 },
  { 'user': 'chandler', 'age': 39 }
]

Tests:

array find
// Native users.slice().reverse().findIndex(function (o) { return o.age === 41; })
_.findLastIndex
_.findLastIndex(users, function (o) { return o.age === 41; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
_.findLastIndex

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

array find

11.2M/s

_.findLastIndex

4.7M/s

View exact numbers

Test name	Executions per second
✓ array find	11,231,049 Ops/sec
_.findLastIndex	4,713,854 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested on the provided JSON?**

The provided JSON represents two test cases that compare the performance of native `reverse()` and `findIndex()` with the external library Lodash's `_.findLastIndex()`. The test cases are:

1. **Native**: Uses the built-in `reverse()` and `findIndex()` methods to search for an element in a reversed array.
2. **Lodash _.findLastIndex**: Uses the Lodash library's `_.findLastIndex()` function to search for an element in the same array.

**Options compared**

The two options are:

1. **Native**: The built-in JavaScript method using `reverse()` and `findIndex()`.
2. **Lodash _.findLastIndex**: The external library Lodash's implementation of the `_.findLastIndex()` function.

**Pros and cons of each approach:**

**Native**

Pros:

* No additional library dependency
* Built-in methods, so no overhead for importing a library
* Native performance, as it's implemented in the browser's engine

Cons:

* Requires reversing the entire array, which can be inefficient if the array is large.
* Uses `findIndex()`, which returns the index of the first matching element, not the last.

**Lodash _.findLastIndex**

Pros:

* More efficient than reversing the entire array, as it only searches until the last element.
* Returns the correct result directly without needing to calculate an index.

Cons:

* Requires importing and loading the Lodash library, which can add overhead.
* May have additional function call overhead due to the library's implementation.

**Other considerations:**

When choosing between these two approaches, consider the following factors:

* **Array size**: If your array is very large, reversing it using `reverse()` might be inefficient. In this case, Lodash's `_findLastIndex()` might be a better choice.
* **Performance-critical code**: If you're writing performance-critical code, you may want to prefer the native implementation for its potential speed advantages.
* **Readability and maintainability**: If readability and maintainability are more important than performance, using Lodash's `_findLastIndex()` might make your code easier to understand.

**Lodash library**

The Lodash library is a popular utility library that provides many useful functions for working with JavaScript data structures. In this case, the `_.findLastIndex()` function is used to search for an element in an array from the end (last index).

**Special JS features or syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

**Other alternatives**

If you don't want to use Lodash, you can also consider implementing your own `_.findLastIndex()` function using JavaScript's built-in methods. This would involve iterating through the array from the end and finding the first matching element, which could be done without the need for an external library.

native reverse findIndex vs lodash _.findLastIndex (version: 1)

Compare lodash findLastIndex with native reverse and findIndex.

Comparing performance of: `array find vs _.findLastIndex`

Created: 4 years ago by: Registered User

Go to the latest result

array find

_.findLastIndex

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

native reverse findIndex vs lodash _.findLastIndex (version: 1)

Compare lodash findLastIndex with native reverse and findIndex.

Comparing performance of: array find vs _.findLastIndex

Created: 4 years ago by: Registered User

Go to the latest result

array find

_.findLastIndex

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `array find vs _.findLastIndex`