Benchmark: get vs channing - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

var user =  { 'a': { 'b': { 'c': 3 } }};

Tests:

_.get
const test1 = _.get(user, 'a.b.c', 'default')
ES6 has
const test2 = user.a?.b?.c || 'default'
ES6 has not
const test3 = user.a?.b1?.c || 'default'
_.get has not
const test4 = _.get(user, 'a.b1.c', 'default')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.get
ES6 has
ES6 has not
_.get has not

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.get	1745054.8 Ops/sec
ES6 has	13420014.0 Ops/sec
ES6 has not	12751309.0 Ops/sec
_.get has not	1803869.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**What is being tested?**

The benchmark tests the performance of three different approaches to access nested properties in an object:

1. **Lodash's `_.get` method**: This approach uses Lodash, a popular utility library for JavaScript.
2. **ES6's optional chaining operator (`?.`)**: This approach takes advantage of the ES6 syntax to safely navigate nested objects without throwing errors.
3. **ES6's property access with default value (`|| 'default'`)**: This approach also leverages ES6 syntax to provide a default value when accessing nested properties.

**Options being compared**

The benchmark is comparing the performance of these three approaches:

* Lodash's `_.get`
* ES6's optional chaining operator (`?.`)
* ES6's property access with default value (`|| 'default'`)

**Pros and cons of each approach**

1. **Lodash's `_.get` method**
	* Pros:
		+ Robust and well-tested, especially for complex nested objects.
		+ Provides a default value if the path doesn't exist.
	* Cons:
		+ Requires an additional dependency (Lodash).
		+ May be slower than native JavaScript approaches due to the overhead of loading Lodash.
2. **ES6's optional chaining operator (`?.` )**
	* Pros:
		+ Fast and efficient, as it only checks for existence if necessary.
		+ Easy to read and understand, as it follows a consistent syntax pattern.
	* Cons:
		+ Only works in modern browsers that support ES6+ features.
		+ May not work correctly with older browsers or environments that don't support `?.`.
3. **ES6's property access with default value (`|| 'default'`)**
	* Pros:
		+ Fast and efficient, as it only checks for existence if necessary.
		+ Easy to read and understand, as it follows a consistent syntax pattern.
	* Cons:
		+ May not work correctly in certain edge cases (e.g., when using `Object.prototype` methods).
		+ May require additional error handling to ensure correct behavior.

**Other considerations**

* The benchmark uses a relatively simple object structure (`user`) and specific nested paths to focus on the performance differences between these approaches.
* The benchmark results are likely skewed by the specific hardware and browser configuration used, which may not represent typical user scenarios.
* Other factors like memory allocation, garbage collection, and JavaScript engine optimizations might also impact performance.

**Alternatives**

If you're looking for alternatives or further optimizations:

1. **Use native JavaScript approaches**: Instead of relying on libraries, you can use simple recursive or iterative functions to access nested properties.
2. **Leverage browser-specific features**: If possible, use browser-specific features like WebAssembly or native modules to improve performance.
3. **Profile and optimize hotspots**: Use profiling tools to identify performance bottlenecks in your codebase and optimize those specific areas.

Keep in mind that this is a simplified benchmark, and real-world scenarios may involve more complexity and nuance. Always consider the specific requirements of your project when choosing an approach.

Related benchmarks:

get vs channing (version: 0)

Comparing performance of: _.get vs ES6 has vs ES6 has not vs _.get has not

Created: 2 years ago by: Guest

Jump to the latest result

_.get

ES6 has

ES6 has not

_.get has not

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):