Benchmark: Lodash.get vs Lodash.property vs native test

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',
    foo: {
        bar: "baz"
    }
};

function get(obj, path, defaultValue = undefined) {
    const travel = regexp =>
        String.prototype.split
        .call(path, regexp)
        .filter(Boolean)
        .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj);
    const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
    return result === undefined || result === obj ? defaultValue : result;
}

Tests:

Lodash get
_.get(person, 'foo.bar');
native
get(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

Latest run results:

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

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

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash get	7074422.5 Ops/sec
native	1337355.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of two approaches to access nested object properties in JavaScript: using the popular utility library Lodash's `get` function and the native JavaScript approach.

**Lodash.get vs Native Test**

1. **Lodash.get**
	* Library: Lodash (version 4.16.0)
	* Purpose: Provides a versatile and flexible way to access nested object properties.
	* Implementation:
		+ The `get` function takes three arguments: the object, the path to the property, and an optional default value.
		+ It uses a regular expression to split the path into individual keys, filters out empty values, and then recursively traverses the object using the reduced approach.
	* Pros:
		+ Highly flexible and customizable
		+ Handles errors and edge cases elegantly
		+ Well-tested and widely adopted in the JavaScript community
	* Cons:
		+ Adds an additional dependency (Lodash)
		+ May introduce unnecessary overhead due to its complexity
2. **Native Test**
	* Purpose: Demonstrates a simple, efficient way to access nested object properties using native JavaScript.
	* Implementation:
		+ The `get` function takes two arguments: the object and the path to the property.
		+ It uses string splitting and indexing to extract the individual keys from the path and then recursively accesses the object properties.
	* Pros:
		+ Lightweight and optimized for performance
		+ No additional dependencies required
		+ Easy to understand and implement
	* Cons:
		+ May require more boilerplate code
		+ Less flexible than Lodash's `get` function

**Considerations**

When choosing between Lodash's `get` function and the native test, consider the following factors:

* Performance: If you need optimal performance, the native test might be a better choice due to its lightweight implementation.
* Flexibility: If you require advanced error handling or customization options, Lodash's `get` function is likely a better fit.
* Readability: The native test code might be more straightforward and easier to understand for developers who prefer a simple, efficient approach.

**Other Alternatives**

If you're not satisfied with the results of this benchmark or need alternative approaches, consider the following options:

1. **Underscore.js**: Another popular utility library that provides similar functionality to Lodash.
2. **Object.keys() and bracket notation**: Alternative approaches for accessing nested object properties using the `Object.keys()` method and bracket notation (`[key]`).
3. **Recursion**: Implementing a recursive function to access nested object properties, which might be suitable for simple use cases but may not be as efficient or scalable as other approaches.

Keep in mind that benchmark results can vary depending on the specific use case, JavaScript engine, and environment. It's essential to test and experiment with different approaches to determine the best fit for your project's requirements.

Related benchmarks:

Lodash.get vs Lodash.property vs native test (version: 0)

Comparing performance of: Lodash get vs native

Created: one year 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 2 months ago):