Benchmark: Array find vs lodash find vs Array some

HTML Preparation code:

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

Tests:

Native find
var a = ['hello', 'a', 'bc']; var b = a.find(item => item === 'bc');
Native some
var a = ['hello', 'a', 'bc']; var b = a.some(item => item === 'bc');
lodash find
var a = ['hello', 'a', 'bc']; var b = _.find(a, item => item === 'bc');
object array native find
var a = [{marble: "hihi0", text:'hello'}, {marble: "hihi1", text:'a'}, {marble: "hihi2", text:'bc'}]; var b = a.find(item => item.marble === 'hihi1');
object array native some
var a = [{marble: "hihi0", text:'hello'}, {marble: "hihi1", text:'a'}, {marble: "hihi2", text:'bc'}]; var b = a.some(item => item.marble === 'hihi1');
object array lodash find
var a = [{marble: "hihi0", text:'hello'}, {marble: "hihi1", text:'a'}, {marble: "hihi2", text:'bc'}]; var b = _.find(a, {marble: "hihi1"});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native find
Native some
lodash find
object array native find
object array native some
object array lodash find

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 27 days ago):

LLMs can make mistakes. Check important info.

The provided benchmark tests the performance of different methods for finding elements within arrays in JavaScript. It compares three approaches—native `.find()` and `.some()` methods, and the lodash library’s `.find()` method.

### Options Compared

1. **Native `Array.prototype.find()` method**:
   - **Test**: `var b = a.find(item => item === 'bc');`
   - **Description**: This method returns the first element in the array that satisfies the provided testing function. If no values satisfy the testing function, it returns `undefined`.
   - **Pros**: Customizable search based on a predicate. Works directly on the array without needing an external library.
   - **Cons**: Performance may vary based on browser implementation.

2. **Native `Array.prototype.some()` method**:
   - **Test**: `var b = a.some(item => item === 'bc');`
   - **Description**: This method tests whether at least one element in the array passes the test implemented by the provided function. Returns a Boolean value.
   - **Pros**: Similar benefits to `.find()`, but can be useful when you just need a Boolean indication of the presence of an element.
   - **Cons**: Returns a Boolean instead of the found element if any.

3. **Lodash `_.find()` function**:
   - **Test**: `var b = _.find(a, item => item === 'bc');`
   - **Description**: This is a function from the lodash library that works similarly to the native `.find()` method but may have additional syntactic options.
   - **Pros**: Lodash is well-optimized for various utility functions and has broader support for different types of collections.
   - **Cons**: Requires loading an external library, which can add overhead and is unnecessary if only this functionality is needed.

### Object Array Tests

In addition to simple value searches, there are tests for finding objects within an array of objects:

1. **Using Native `Array.prototype.find()` with Objects**:
   - **Test**: Searches for an object based on a property.
   - **Pros**: Directly leverages the native array method that is straightforward.
   - **Cons**: Performance implications can differ based on object size and complexity.

2. **Using Lodash with Objects**:
   - **Test**: Searches for an object using the lodash library.
   - **Pros**: Lodash provides a clean interface with more options for complex searches, such as shorthand property matching.
   - **Cons**: As with previous lodash tests, it involves external library overhead.

### Performance Results Summary

The benchmark results show the execution speed (in executions per second) for each method, giving insight into which is the fastest under similar conditions. For instance, the native `.find()` method appears to perform best, followed by `.some()`, with lodash methods trailing, suggesting potential inefficiencies or overhead when using the library.

### Considerations

- **Performance**: When implementing a search function, native methods are generally faster due to their integration into the language and optimizations by the JavaScript engine.
- **Readability vs. Performance**: Lodash provides a more readable syntax, especially for complex searches, but may not be necessary for simple cases. Consider your project needs when deciding on using a library.
- **Library Usage**: Including libraries can lead to bloated code if only a few functions are utilized. Conversely, if you rely heavily on utility functions, it may be worth it.

### Alternatives

Many programming patterns and libraries exist as alternatives for array searching, including:

- **Array methods**: Additional native methods like `filter()` can be used, though they return an array of all matching items instead of just the first.
- **Other Libraries**: Alternative utility libraries such as Ramda or Even.js also provide similar methods with different syntax and features.
- **Custom Implementations**: For highly specific needs, writing a custom search function might be beneficial, striking a balance between performance and functionality.

By understanding these options, developers can make more informed decisions about performance, readability, and the necessity of external libraries in their JavaScript applications.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Native find	144245392.0 Ops/sec
Native some	142290384.0 Ops/sec
lodash find	11205143.0 Ops/sec
object array native find	102058888.0 Ops/sec
object array native some	95066248.0 Ops/sec
object array lodash find	4990774.5 Ops/sec

Related benchmarks:

Array find vs lodash find vs Array some (version: 1)

Comparing performance of: Native find vs Native some vs lodash find vs object array native find vs object array native some vs object array lodash find

Created: 27 days ago by: Registered User

Jump to the latest result

Native find

Native some

lodash find

object array native find

object array native some

object array lodash find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 27 days ago):