Benchmark: native reverse find vs native array findLast

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': 'joey',  'age': 32 },
  { 'user': 'ross',    'age': 41 },
  { 'user': 'joey',  'age': 32 },
  { 'user': 'ross',    'age': 41 },
  { 'user': 'joey',  'age': 32 },
  { 'user': 'ross',    'age': 41 },
  { 'user': 'chandler', 'age': 39 }
]

Tests:

array find
// Native users.slice().reverse().find(function (o) { return o.age < 40; })
array findlast
users.slice().findLast(function (o) { return o.age < 40; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
array findlast

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Linux

View result in a separate tab

Test name	Executions per second
array find	27980460.0 Ops/sec
array findlast	32480386.0 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):

LLMs can make mistakes. Check important info.

This benchmark on MeasureThat.net compares the performance of two methods for finding a user in an array based on their age:

* **`array find`:**  This approach uses `slice()` to create a copy of the `users` array, reverses it using `.reverse()`, and then employs the `.find()` method to locate the first user whose age is less than 40.

* **`array findLast`:** This method directly utilizes the newer `.findLast()` function on the original `users` array to find the last user with an age less than 40.

**Pros and Cons:**

* **`array find`:**
    * **Cons:** Requires more steps, potentially impacting performance due to extra array operations. Reversing the array adds extra overhead.

* **`array findLast`:**
    * **Pros:** More concise and efficient as it directly targets the desired element without requiring extra array manipulations.

**Other Considerations:**

*  The benchmark doesn't factor in potential edge cases (e.g., an empty array) or variations in data size. Real-world performance might differ depending on these factors.
* The `lodash` library isn't actively used in this benchmark, though it's included in the HTML preparation code for unknown reasons.

**Alternatives:**

1. **Using a loop:** A traditional `for` loop could achieve the same result as `.find()` or `.findLast()`, offering fine-grained control but potentially being less efficient for large arrays.

2. **Sorting the array:** If you frequently need to find specific elements based on order, sorting the array beforehand can make searching more efficient using binary search algorithms.

Let me know if you have any other questions!

Related benchmarks:

native reverse find vs native array findLast (version: 0)

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

Comparing performance of: array find vs array findlast

Created: one year ago by: Guest

Jump to the latest result

array find

array findlast

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):