Benchmark: Lodash get() comparison

HTML Preparation code:

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

Script Preparation code:

let noData = {};
let partialData = {prop:{names: {}}};
let fullData = {prop: {names: {here: "asdf"}}};

function readableGet(input) {
  return _.get(input, "prop.names.here");
}

function nonReadableGet(input) {
  return _.get(input, ["prop", "names", "here"]);
}

function test(fn, input, key) {
  fn(input, key);
}

Tests:

Readable Get - No Data
test(readableGet, {});
Non-Readable Get - No Data
test(nonReadableGet, {});
Readable Get - Partial Data
test(readableGet, {prop:{names: {}}});
Non-Readable Get - Partial Data
test(nonReadableGet, {prop:{names: {}}});
Readable Get - Full Data
test(readableGet, {prop: {names: {here: "asdf"}}});
Non-Readable Get - Full Data
test(nonReadableGet, {prop: {names: {here: "asdf"}}});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Readable Get - No Data
Non-Readable Get - No Data
Readable Get - Partial Data
Non-Readable Get - Partial Data
Readable Get - Full Data
Non-Readable Get - Full Data

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 its components.

**Benchmark Description**

The benchmark is comparing two ways to access nested data in an object using the Lodash `get()` function: readable and non-readable notation.

* Readable notation uses the dot (`.`) separator, e.g., `data.prop.names.here`.
* Non-readable notation uses bracket notation (`[]`), e.g., `data['prop.names.here']`.

**Script Preparation Code**

The script preparation code sets up three test data objects:

1. `noData`: an empty object.
2. `partialData`: an object with a nested property `prop` containing another nested object `names`.
3. `fullData`: the same as `partialData`, but with an additional property `here` that contains a value.

It also defines two functions:

* `readableGet(input, key)`: calls Lodash's `get()` function with readable notation.
* `nonReadableGet(input, key)`: calls Lodash's `get()` function with non-readable notation.

**Html Preparation Code**

The HTML preparation code includes the Lodash library from a CDN.

**Options Compared**

The benchmark is comparing two options:

1. **Readable notation**: uses the dot (`.`) separator to access nested data.
2. **Non-readable notation**: uses bracket notation (`[]`) to access nested data.

**Pros and Cons**

* Readable notation:
	+ Pros: more human-readable, easier to understand for developers.
	+ Cons: may be slower due to string lookup, as the browser needs to look up the key in the object's `names` property.
* Non-readable notation:
	+ Pros: potentially faster, as bracket notation is a direct access operation.
	+ Cons: less human-readable, may require more effort to understand for developers.

**Library**

Lodash is a popular JavaScript utility library that provides a wide range of functions for working with data. The `get()` function is one of its most useful features, allowing you to safely navigate nested objects and arrays.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Other Alternatives**

If Lodash's `get()` function were not used, the same functionality could be achieved using other libraries or built-in JavaScript methods, such as:

* Using bracket notation (`[]`) with the `in` operator to check for property existence.
* Implementing a custom `get()` function using recursion or iteration.

However, this would likely result in more complex and less readable code.

Latest run results:

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

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

Browser/OS: Chrome 78 on Linux

View result in a separate tab

Test name	Executions per second
Readable Get - No Data	1788997.8 Ops/sec
Non-Readable Get - No Data	2863530.2 Ops/sec
Readable Get - Partial Data	1466426.2 Ops/sec
Non-Readable Get - Partial Data	2414013.0 Ops/sec
Readable Get - Full Data	1464765.4 Ops/sec
Non-Readable Get - Full Data	2373988.2 Ops/sec

Related benchmarks:

Lodash get() comparison (version: 0)

Compares get(data, "prop.names.here") vs get(data, ["prop", "names", "here"]

Comparing performance of: Readable Get - No Data vs Non-Readable Get - No Data vs Readable Get - Partial Data vs Non-Readable Get - Partial Data vs Readable Get - Full Data vs Non-Readable Get - Full Data

Created: 4 years ago by: Guest

Jump to the latest result

Readable Get - No Data

Non-Readable Get - No Data

Readable Get - Partial Data

Non-Readable Get - Partial Data

Readable Get - Full Data

Non-Readable Get - Full Data

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