Benchmark: Lodash.get vs safeGet vs Null operator

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', nested: {name: 'test'}};
function safeGet(obj, path, defaultValue) {
  return path.split('.').reduce((xs, x) => (xs && xs[x]) ? xs[x] : defaultValue, obj);
}

Tests:

Lodash get
_.get(person, 'name', ''); _.get(person, 'nested.name', '');
safeGet
safeGet(person, 'name', ''); safeGet(person, 'nested.name', '');
Null operator
person?.name ?? ''; person?.nested?.name ?? '';
Or Operator
person?.name || ''; person?.nested?.name || '';
Direct
person.name; person.nested.name;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
safeGet
Null operator
Or Operator
Direct

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Lodash get	3904029.2 Ops/sec
safeGet	5681454.0 Ops/sec
Null operator	17298478.0 Ops/sec
Or Operator	17397892.0 Ops/sec
Direct	17467270.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark provided is a performance comparison between different methods to safely access properties in a JavaScript object. The core of the test is to evaluate several approaches for getting nested properties from an object, specifically testing:

1. **Lodash's `_.get`** - A utility function from the Lodash library.
2. **Safe access function `safeGet`** - A custom implementation.
3. **Nullish coalescing operator (`??`)** - A modern JavaScript feature.
4. **Logical OR operator (`||`)** - A traditional approach.
5. **Direct property access** - The simplest and most straightforward method.

### Approaches Compared

1. **Lodash's `_.get`**:
   - **Description**: A function that safely retrieves a value from an object at a specified path and returns a default value if the path is undefined.
   - **Pros**: 
     - Handles deep property access and can work with paths that may not exist.
     - Well-tested and widely used in many projects, leading to reliability.
   - **Cons**: 
     - Typically slower due to the overhead of function calls and internal logic.
     - Requires importing an external library, adding to the bundle size.

2. **Custom `safeGet`**:
   - **Description**: A manual implementation that splits the path string into keys and then accesses them iteratively.
   - **Pros**: 
     - No dependency on external libraries and can be easily customized.
     - Provides a performance advantage over Lodash if optimized.
   - **Cons**: 
     - More susceptible to errors if not implemented correctly.
     - Slightly less readable compared to Lodash since it re-implements similar functionality.

3. **Nullish Coalescing Operator (`??`)**:
   - **Description**: A feature introduced in ES2020 that returns the right-hand operand when the left-hand operand is `null` or `undefined`.
   - **Pros**: 
     - Highly efficient and succinct syntax for handling falsy values.
     - Built-in language feature, no extra logic required.
   - **Cons**: 
     - Only works in modern JavaScript environments; may not be supported in older browsers.
     - Does not cover scenarios where other falsy values (like `0` or `''`) may need to be handled.

4. **Logical OR Operator (`||`)**:
   - **Description**: A traditional method that returns the left-hand operand if it’s truthy, otherwise returns the right-hand operand.
   - **Pros**: 
     - Readily available and works in virtually all JavaScript environments.
     - Very easy to understand.
   - **Cons**: 
     - Can lead to unexpected behavior with falsy values (e.g., `0`, `''`) since they will return the default value.
   
5. **Direct Property Access**:
   - **Description**: Directly accesses the property using the dot notation.
   - **Pros**: 
     - Fastest approach since it doesn't have any function overhead.
     - Simple and easy to read.
   - **Cons**: 
     - Throws an error if any part of the path doesn't exist, which can lead to runtime issues.
     - Not suitable for accessing deeply nested properties safely without prior checks.

### Benchmark Results Analysis

The benchmark results show the "Executions Per Second" for each method, highlighting that the fastest methods were **Direct Property Access** and the **Null Operator**, both benefiting from their straightforward access strategies. Meanwhile, the methods using Lodash and the custom `safeGet` were significantly slower due to the additional complexity inherent in both approaches.

### Alternatives

Other alternatives that could be considered for accessing properties safely include:

- **Optional Chaining (`?.`)**: Similar to the tested null operator, it can help in safely accessing nested properties and can be combined with the nullish coalescing operator for safe defaults.
  
- **TypeScript's Type Safety**: Using strong typing can help avoid accessing undefined properties at runtime, although this may not reflect directly in performance benchmarks.
  
- **Use of Proxy objects**: A more advanced JavaScript feature that can define custom behaviors for fundamental operations (e.g., property access), but with added complexity.

Overall, the test case effectively showcases the performance differences between different methodologies for property access in JavaScript, providing insights pertinent to software engineers when choosing which approach to utilize based on the requirements for safety, performance, and dependency management.

Related benchmarks:

Lodash.get vs safeGet vs Null operator (version: 0)

Comparing performance of: Lodash get vs safeGet vs Null operator vs Or Operator vs Direct

Created: 2 months ago by: Guest

Jump to the latest result

Lodash get

safeGet

Null operator

Or Operator

Direct

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):