Benchmark: Lodash.get vs native 2022

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

var person = {name: 'Frederick', lastName: 'Corcino Alejo', foo: { bar: "baz" } };

Tests:

Lodash get
_.get(person, 'foo.bar');
Native
person?.foo?.bar;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
Native

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and some considerations.

**Benchmark Overview**

The benchmark compares two approaches to access nested properties in JavaScript:

1. Lodash (`_.get` method)
2. Native syntax (using optional chaining `?.`)

**Lodash `.get` Method**

Lodash is a utility library that provides various helper functions for tasks like string manipulation, array manipulation, and more. The `.get` method is specifically designed to access nested properties in an object.

In the benchmark, Lodash is included using a CDN link, and the script preparation code defines a simple `person` object with nested properties (`foo.bar`). The test case uses the `_get` method to access `foo.bar`.

**Native Syntax (Optional Chaining)**

The native syntax for accessing nested properties in JavaScript has been introduced in ECMAScript 2020. It allows you to access nested properties using a more concise syntax, making your code more readable and expressive.

In this benchmark, the test case uses the native syntax (`person?.foo?.bar`) to access `foo.bar`.

**Comparison**

The two approaches are compared in terms of performance (number of executions per second).

**Pros and Cons**

**Lodash `.get` Method:**

Pros:

* More explicit and readable way to access nested properties
* Can be useful when working with complex data structures

Cons:

* Adds extra overhead due to the library being loaded
* May not be as efficient as native syntax for simple cases

Native Syntax (Optional Chaining):

Pros:

* More concise and expressive way to access nested properties
* Efficient and optimized by the JavaScript engine

Cons:

* May require more parentheses or chaining, making it less readable in some cases
* Not all browsers support ECMAScript 2020 features

**Other Considerations**

* The benchmark uses Chrome 104 as the browser, which supports both Lodash and native syntax.
* The test case is run on a Linux desktop platform, which may affect performance due to the operating system and hardware characteristics.

**Alternatives**

If you're interested in exploring other alternatives, consider:

* Other utility libraries like `lodash-es` or `ramda`, which offer similar functionality
* Using JavaScript built-in methods like `in` and `hasOwnProperty` for accessing nested properties (although less readable and concise)
* Caching or memoization techniques to reduce the number of property accesses

Keep in mind that benchmarking results can vary depending on the specific use case, data structure, and performance requirements.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36

Browser/OS: Chrome 104 on Linux

View result in a separate tab

Test name	Executions per second
Lodash get	3731296.0 Ops/sec
Native	22733074.0 Ops/sec

Related benchmarks:

Lodash.get vs native 2022 (version: 0)

Comparing performance of: Lodash get vs Native

Created: 2 years ago by: Guest

Jump to the latest result

Lodash get

Native

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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