Benchmark: lodash get vs reduce get vs native access

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var props = {
  user: {
    posts: [
      { title: 'Foo', comments: [ 'Good one!', 'Interesting...' ] },
      { title: 'Bar', comments: [ 'Ok' ] },
      { title: 'Baz', comments: [] },
    ]
  }
}

var get = (o, p) =>
  p.reduce((xs, x) => (xs && xs[x]) ? xs[x] : null, o);

Tests:

lodash
var comment = _.get(props, 'user.posts[0].comments[0]') var noise = comment + 'noise';
reduce get
var comment = get(props, ['user', 'posts', 0, 'comments', 0]); var noise = comment + 'noise';
native access
var comment = props.user.posts[0].comments[0]; var noise = comment + 'noise';

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
reduce get
native access

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
lodash	1282716.6 Ops/sec
reduce get	2357910.2 Ops/sec
native access	7100489.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmarking test case on the MeasureThat.net website. The benchmark compares the performance of three approaches to access an object's property in a nested object:

1. **Lodash `.get()` method**
2. **Reduce-based approach (`reduce get`)**

The test also includes a third option: **Native access**.

**Lodash `.get()` Method**

The Lodash library is a utility belt for JavaScript that provides various functions to perform tasks such as string manipulation, array manipulation, and object manipulation.

In this benchmark, the `_.get()` method is used to access an object's property in a nested object. The `_.get()` method takes two arguments: the first argument is the object to search (`o`), and the second argument is the path to the desired property (e.g., `'user.posts[0].comments[0]'`).

Pros of using `.get()`:

* Concise and readable code
* Handles nested objects with ease
* Reduces typos and errors

Cons of using `.get()`:

* Adds an additional dependency on Lodash library
* May have a slight overhead due to the library's existence

**Reduce-based Approach (`reduce get`)**

The reduce-based approach uses the `Array.prototype.reduce()` method to iterate over the nested object path and retrieve the desired property.

Pros of using reduce:

* No additional dependencies (native JavaScript only)
* Can be optimized for performance by avoiding unnecessary iterations
* Simple to implement

Cons of using reduce:

* Requires more code compared to `.get()`
* May have a higher risk of typos or errors due to the manual path specification

**Native Access**

The native access approach simply accesses the nested object property directly, without using any library functions.

Pros of using native access:

* Fastest execution time (no overhead from libraries)
* No dependencies on other libraries
* Simple and straightforward code

Cons of using native access:

* Requires manual knowledge of the object structure and path
* May have errors or typos if not implemented correctly

**Other Considerations**

* The benchmark results are likely affected by factors such as:
	+ Browser performance and version
	+ Device platform and operating system
	+ Hardware configuration (CPU, memory, etc.)
* MeasureThat.net may use additional optimization techniques, such as caching or parallel execution, to improve benchmarking accuracy.

**Alternatives**

If you're interested in exploring alternative approaches for accessing nested object properties, consider the following:

* Using `Object.prototype.hasOwnProperty()` and chaining methods to access properties (not recommended due to its slow performance)
* Utilizing ES6's optional chaining (`?.`) syntax to safely navigate nested objects
* Implementing your own optimized library or helper functions

Keep in mind that each approach has trade-offs in terms of performance, readability, and maintenance. The choice ultimately depends on the specific requirements of your project and your personal preferences as a developer.

Related benchmarks:

lodash get vs reduce get vs native access (version: 0)

Comparing performance of: lodash vs reduce get vs native access

Created: 3 years ago by: Guest

Jump to the latest result

lodash

reduce get

native access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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