Benchmark: Lodash.get vs Lodash.property vs native with ?

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var person = {name: 'Frederick', lastName: 'Corcino Alejo', foo: { bar: "baz" } };
var p = _.property("foo.bar");

Tests:

Lodash get
_.get(person, 'foo.bar');
_property
p(person);
native ?
person?.foo?.bar;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
_property
native ?

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash get	8045291.0 Ops/sec
_property	8411388.0 Ops/sec
native ?	97197216.0 Ops/sec

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

LLMs can make mistakes. Check important info.

This benchmark compares the performance of three different approaches to access a deeply nested property in a JavaScript object: using Lodash's `get` method, creating a property accessor with Lodash's `property`, and using the optional chaining operator (`?.`) available natively in JavaScript.

### Benchmark Options:

1. **Lodash `get` Method**:
   - **Test Case**: `_.get(person, 'foo.bar');`
   - **Description**: Lodash's `get` function allows for safe property access. It handles cases where the property may not exist without throwing an error, and allows for default values.
   - **Pros**:
     - Handles missing properties gracefully.
     - Can provide a default value if the path does not resolve.
     - Generally readable and expressive.
   - **Cons**:
     - Overhead of function calls can lead to slower performance compared to native access.
     - Needs to load the Lodash library if not already included.

2. **Lodash `property` Method**:
   - **Test Case**: `p(person);` (where `p` is created as `var p = _.property("foo.bar");`)
   - **Description**: This function returns a function that retrieves the value at a specified path in the object. It must be called to evaluate, making it a bit different from direct property access.
   - **Pros**:
     - Can be useful for creating reusable property accessors.
     - Slightly faster than `_.get`, especially when called multiple times with the same path.
   - **Cons**:
     - Still a function call, so it incurs overhead.
     - Less readable compared to direct access methods and less commonly used for simple property lookups.

3. **Native Optional Chaining**:
   - **Test Case**: `person?.foo?.bar;`
   - **Description**: This syntax allows access to properties while safely checking if the preceding property exists. If any part of the chain is `null` or `undefined`, the expression short-circuits and returns `undefined` without throwing an error.
   - **Pros**:
     - Direct, clean syntax for property access.
     - No additional library is required, resulting in better performance.
     - Easily understandable for developers familiar with the language.
   - **Cons**:
     - Can only be used in supported environments (ES2020 and later). Older browsers or environments may not support this feature.

### Performance Results:

From the benchmark results, we can see the number of executions per second for each method:

- **Native Optional Chaining**: 97,197,216 executions/second (fastest)
- **Lodash Property**: 8,411,388 executions/second
- **Lodash Get**: 8,045,291 executions/second

### Summary of Considerations:

- **Performance**: The native optional chaining operator is significantly faster than both Lodash methods due to reduced overhead.
- **Readability and Safety**: Lodash provides good safety features and readability, especially for developers who prioritize managing potentially missing properties. However, the overhead for performance-sensitive applications may not justify its use.
- **Library Dependencies**: If you're including Lodash in your project solely for property access, it may be worth considering native solutions to minimize payload size and increase performance.
  
### Alternatives:

Other alternatives for handling property access include:

- **Simple conditional checks**: Using multiple `if` statements (though less clean).
- **Try/Catch statements** to catch undefined errors, though this approach is generally inefficient and error-prone.
- **TypeScript**: Utilizing TypeScript with interface definitions can help prevent runtime access errors and is a robust alternative if you're working in a typed context.

In conclusion, while Lodash offers powerful utility functions, the native optional chaining is preferable for accessing nested properties when performance is a key concern, provided it is supported in your target runtime environment.

Related benchmarks:

Lodash.get vs Lodash.property vs native with ? (version: 1)

Comparing performance of: Lodash get vs _property vs native ?

Created: 16 days ago by: Guest

Jump to the latest result

Lodash get

_property

native ?

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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