Benchmark: Lodash.js vs Native access object

HTML Preparation code:

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

Script Preparation code:

const data = {
    member: {
        id: 1,
        name: 'a',
        biz: {
            id: 1,
            name: 'a'
        }
    }
}

Tests:

Native access dot notation
const bizId = data.member.biz.id const memberId = data.member.id const bizName = data.member.biz.name const memberName = data.member.name
Lodash.js get
const bizId = _.get(data, 'member.biz.id') const memberId = _.get(data, 'member.id') const bizName = _.get(data, 'member.biz.name') const memberName = _.get(data, 'member.name')
Native access dot notation : pass by reference
const member = data.member const biz = member.biz const bizId = biz.id const memberId = member.id const bizName = biz.name const memberName = member.name
Lodash.js get : pass by reference
const member = _.get(data, 'member') const biz = _.get(member, 'biz') const bizId = _.get(biz, 'id') const memberId = _.get(member, 'id') const bizName = _.get(biz, 'name') const memberName = _.get(member, 'name')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native access dot notation
Lodash.js get
Native access dot notation : pass by reference
Lodash.js get : pass by reference

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native access dot notation	7440157.5 Ops/sec
Lodash.js get	1541400.8 Ops/sec
Native access dot notation : pass by reference	26984680.0 Ops/sec
Lodash.js get : pass by reference	2185216.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests two different approaches for accessing properties of a nested JavaScript object, comparing native JavaScript dot notation with the Lodash utility library's `_.get` method. This allows developers to evaluate performance differences in terms of execution speed, specifically focusing on how data is accessed within objects.

### Options Compared

1. **Native Access Dot Notation**
   - **Test Cases:**
     - `Native access dot notation`: Directly accesses the properties of the object using dot notation.
     - `Native access dot notation: pass by reference`: Stores references to nested objects before accessing properties.
   - **Description:**
     - This approach uses the language's built-in syntax for property access. 
     - For example: `data.member.biz.id` accesses `id` directly without any abstraction.

2. **Lodash.js get Method**
   - **Test Cases:**
     - `Lodash.js get`: Uses `_.get` to access properties in a more abstract and safer way.
     - `Lodash.js get: pass by reference`: Similar to the dot notation with reference passing but uses `_.get`.
   - **Library Purpose:**
     - Lodash is a utility library that simplifies tasks such as deep property access, manipulation, and functional programming patterns. The `_.get` method is particularly useful because it allows for safe property access—if a property doesn’t exist in the path defined, it returns `undefined` instead of potentially causing a TypeError.

### Performance Results

The benchmark results indicate significant performance differences between the approaches:

- **Native access dot notation (pass by reference)** achieved the highest performance, executing nearly 27 million operations per second. This indicates that simple direct access is the most efficient way to retrieve data, likely due to the reduced overhead involved in using native syntax.
  
- **Native access dot notation** (without reference passing) performed reasonably well, but not as fast as when using references, at about 7.4 million operations per second.

- **Lodash's `_.get` method (pass by reference)** showed much lower performance at 2.1 million operations per second. This reflects the overhead of function calls and additional safety features that Lodash provides.

- **Lodash's `_.get` method** without reference passing demonstrated the least performance at 1.5 million operations per second, confirming that both function call overhead and property path traversal impact speed.

### Pros and Cons

#### Native Access
- **Pros:**
  - Fastest performance.
  - Straightforward syntax that is familiar to most JavaScript developers.
- **Cons:**
  - Less safe when accessing deeply nested properties; if any part of the chain is `undefined` or `null`, an error occurs.

#### Lodash `_.get()` Method
- **Pros:**
  - Provides a safe way to access nested properties; avoids runtime errors.
  - Can specify a default value if a property is not found.
- **Cons:**
  - Slower performance due to the additional function calls and overhead.
  - Slightly more verbose syntax which may be less readable for simple cases.

### Other Considerations
- Depending on the complexity of the object structure and error handling needs, developers may prefer one method over another. For internal applications or situations where performance is critical, native access is preferable. Conversely, for applications requiring robust error handling or dealing with uncertain data structures (e.g., user input), Lodash's `_.get` can provide peace of mind.

### Alternatives
- Beyond Lodash, native JavaScript provides optional chaining (`?.`), which can be a modern and safer alternative to access nested properties without error handling. For example, `data.member?.biz?.id` would return `undefined` if any part of the chain is `undefined`, thus avoiding runtime errors while maintaining close performance to native access.

In summary, engineers can choose between native access for speed and performance or use Lodash for safety and flexibility, with modern JavaScript syntax offering additional options for robust property access.

Related benchmarks:

Lodash.js vs Native access object (version: 1)

Comparing performance of: Native access dot notation vs Lodash.js get vs Native access dot notation : pass by reference vs Lodash.js get : pass by reference

Created: one month ago by: Guest

Jump to the latest result

Native access dot notation

Lodash.js get

Native access dot notation : pass by reference

Lodash.js get : pass by reference

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):