Benchmark: Lodash.get vs Lodash.property vs Dot vs Brackets

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" } };
var p = _.property("foo.bar");
let t;

Tests:

Lodash get
t =_.get(person, 'foo.bar');
_property
t = p(person);
native
t = person.foo.bar;
brackets
t = person['foo']['bar']

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
_property
native
brackets

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/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash get	3785226.5 Ops/sec
_property	4489208.5 Ops/sec
native	8903426.0 Ops/sec
brackets	8896276.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll explain the benchmark in detail.

**Overview**

MeasureThat.net is a website where users can create and run JavaScript microbenchmarks to compare different approaches to achieve similar results. The provided benchmark compares four methods: `Lodash.get`, `_property`, dot notation (`.`), and bracket notation (`[]`).

**Benchmark Definition**

The benchmark definition json contains the following information:

* `Name`: The name of the benchmark, which is "Lodash.get vs Lodash.property vs Dot vs Brackets".
* `Script Preparation Code`: A JavaScript code snippet that prepares a test case. In this case, it creates an object `person` with nested properties and assigns a value to one of those properties using Lodash's `_property` function.
* `Html Preparation Code`: An HTML link that includes the Lodash library version 4.16.0.

**Individual Test Cases**

The benchmark consists of four individual test cases, each defined in the following format:

* `Benchmark Definition`: A JavaScript code snippet that executes the desired operation on the prepared `person` object.
* `Test Name`: The name of the test case, which corresponds to one of the four methods being compared.

Here's a brief explanation of each test case:

1. `Lodash get`: Uses Lodash's `_get` function to access the nested property `foo.bar`.
2. `_property`: Uses Lodash's `_property` function to access the nested property `foo.bar`. This is equivalent to using dot notation.
3. `native`: Directly accesses the nested property `foo.bar` without using any libraries or functions.
4. `brackets`: Accesses the nested property `foo.bar` by using bracket notation (`[]`) on the `person` object.

**Library and Purpose**

The Lodash library is a popular utility library for JavaScript that provides a wide range of functions for tasks such as array manipulation, string manipulation, and more. In this benchmark, two Lodash functions are used:

* `_get`: A function that accesses nested properties in an object.
* `_property`: A function that sets or gets the value of a property on an object.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. `Lodash get`:
	* Pros: Convenient, easy to use, and flexible for accessing nested properties.
	* Cons: Adds overhead due to the library call and might be slower than native approaches.
2. `_property`:
	* Pros: Easy to use and flexible for setting or getting property values.
	* Cons: Similar to `_get`, adds overhead due to the library call.
3. `native`:
	* Pros: Fastest approach, no added overhead from libraries or functions.
	* Cons: Requires manual handling of nested properties, more error-prone.
4. `brackets`:
	* Pros: Simple and concise way to access nested properties using bracket notation.
	* Cons: Less convenient than other approaches, might not be as flexible.

**Other Considerations**

When choosing an approach, consider the following factors:

* Performance: If speed is critical, native or bracket notation might be the best choice. However, if convenience and flexibility are more important, Lodash functions like `_get` or `_property` might be a better fit.
* Readability: Dot notation and bracket notation can make code more readable by explicitly conveying the intent of accessing nested properties.
* Error handling: Native approaches require manual error handling for nested properties. Lodash functions like `_get` or `_property` handle errors internally.

**Alternatives**

Other alternatives to access nested properties include:

* `in`: A native JavaScript operator that returns a boolean indicating whether a property exists in an object. (Example: `person['foo']['bar']`)
* `for...in`: A loop construct that iterates over the own enumerable properties of an object. (Example: `for (var prop in person.foo) { console.log(person.foo[prop]); }`)

Related benchmarks:

Lodash.get vs Lodash.property vs Dot vs Brackets (version: 0)

Comparing performance of: Lodash get vs _property vs native vs brackets

Created: 5 years ago by: Guest

Jump to the latest result

Lodash get

_property

native

brackets

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