Benchmark: native find vs lodash _.find_fork

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 users = Array.from(Array(10000).keys()).map(age => ([{
        'user': age,
        'age': age
    },
]))

Tests:

array find
// Native users.find(function (o) { return o.age < 5000; })
_.find
_.find(users, function (o) { return o.age < 5000; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
_.find

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definitions and explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Definition JSON**

The provided JSON represents a microbenchmarking test created using MeasureThat.net. It has three main sections:

1. **Script Preparation Code**: This section is executed before running the benchmark tests. In this case, it generates an array of 10,000 objects with 'user' and 'age' properties.
2. **Html Preparation Code**: This section includes a script tag that loads the Lodash library version 4.17.11. Lodash is a popular JavaScript utility library.
3. **Benchmark Definition**: This section defines two benchmark tests:

* `array find`: Tests finding an element in an array using the native `find()` method.
   * `_.find`: Tests finding an element in an array using the `_find` function from the loaded Lodash library.

**Options Compared**

The two options being compared are:

* **Native `find()`**: The built-in `find()` method of JavaScript arrays, which returns the first element that satisfies the provided callback function.
* **Lodash `_find`**: A higher-order function provided by the Lodash library that performs a similar operation as the native `find()` method.

**Pros and Cons**

*   **Native `find()`**:
    *   Pros:
        *   Faster execution, since it doesn't incur the overhead of loading an external library.
        *   Lower memory usage, as it doesn't load an additional library.
    *   Cons:
        *   Not all browsers or environments support native `find()`, so this benchmark may not be representative for those platforms.
*   **Lodash `_find`**:
    *   Pros:
        *   Well-tested and widely supported across various browsers and environments.
        *   Provides additional features and functionality that might be useful in certain situations.
    *   Cons:
        *   Slower execution, due to the overhead of loading an external library and potential JIT compilation.
        *   Higher memory usage, as it loads an additional library.

**Other Considerations**

*   The test cases use a simple array of 10,000 objects with 'user' and 'age' properties. This can lead to a large number of iterations in the benchmark, making even small differences between the two methods more noticeable.
*   The benchmark only tests finding an element in the array that satisfies a specific condition (i.e., `o.age < 5000`). This might not accurately represent real-world scenarios where you need to find elements that satisfy more complex conditions.

**Library: Lodash**

Lodash is a popular JavaScript utility library developed by Isaac Schlueter and Dean Edwards. It provides over 120 functions for tasks such as:

*   String manipulation
*   Array and object iteration
*   Function composition
*   Utilities for working with dates, numbers, and more

In this benchmark, Lodash's `_find` function is used to find an element in the `users` array that satisfies a given condition. The `_find` function takes two arguments: the array to search and the callback function to execute on each element.

**Special JS Feature/Syntax**

There isn't any special JavaScript feature or syntax being tested in this benchmark, as both native `find()` and Lodash's `_find` are implementing the standard array method.

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/92.0.4515.159 Safari/537.36 Edg/92.0.902.84

Browser/OS: Chrome 92 on Windows

View result in a separate tab

Test name	Executions per second
array find	53588.3 Ops/sec
_.find	153614.5 Ops/sec

Related benchmarks:

native find vs lodash _.find_fork (version: 0)

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

Comparing performance of: array find vs _.find

Created: 3 years ago by: Guest

Jump to the latest result

array find

_.find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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