Benchmark: get lodash perf - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

var testing = { one: 1, two: 2, three: 3, four: 4 }
var get = function(key){ return testing[key] }

Tests:

lodash get
_.get(testing,'one') _.get(testing,'two') _.get(testing,'three') _.get(testing,'four')
direct get
testing['one'] testing['two'] testing['three'] testing['four']
function get
get('one') get('two') get('three') get('four')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash get
direct get
function get

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what's being tested, compare different approaches, discuss pros and cons, and highlight any notable libraries or features used.

**Benchmark Definition**

The benchmark is defined by providing two types of preparation code:

1. **Script Preparation Code**: This code defines an object `testing` with four properties (`one`, `two`, `three`, and `four`) each initialized to a unique value (e.g., 1, 2, 3, and 4). It also defines a function `get` that takes a key as an argument and returns the corresponding value from the `testing` object. The script preparation code is essentially setting up the test data.

2. **Html Preparation Code**: This code includes a link to include the Lodash library (`https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.16.4/lodash.min.js`). Lodash is a utility library for functional programming in JavaScript, and it provides various functions for manipulating arrays, objects, numbers, and more.

**Individual Test Cases**

The benchmark consists of three test cases:

1. **"lodash get"**: This test case uses the `_.get` function from Lodash to access the values in the `testing` object. It iteratively calls `_.get` with different keys (`'one'`, `'two'`, `'three'`, and `'four'`) to measure the performance of using Lodash's accessor function.

2. **"direct get"`: This test case uses the bracket notation (`testing['key']`) to access the values in the `testing` object directly, without relying on a utility function like `_.get`. It iterates over the same keys as the previous test case to measure the performance of direct property access.

3. **"function get"`: This test case uses the custom `get` function defined in the script preparation code (`var get = function(key){ return testing[key] }`) to access the values in the `testing` object. It iterates over the same keys as the previous two test cases to measure the performance of using a custom accessor function.

**Comparison and Pros/Cons**

The three test cases are designed to compare the performance of:

1. **Lodash's accessor function (`_.get`)**: This approach is convenient for accessing nested objects, but it may incur a small overhead due to the added function call.
	* Pros: Easy to use, concise syntax, well-tested and maintained.
	* Cons: May introduce an extra function call, potentially affecting performance.
2. **Direct property access (`testing['key']`)**: This approach is simple and lightweight, but it may require more boilerplate code for accessing nested objects.
	* Pros: Lightweight, easy to understand, no overhead from additional functions.
	* Cons: Can be error-prone, requires more verbose syntax for nested accesses.
3. **Custom accessor function (`get(key)`)**: This approach provides fine-grained control over the accessor process but may require more maintenance and testing effort.
	* Pros: Provides direct control over the accessor logic, can be optimized for specific use cases.
	* Cons: Requires additional setup and testing effort, may incur overhead from custom function creation.

**Notable Libraries**

The benchmark uses Lodash as a utility library to provide the `_.get` function. Lodash is a widely used and well-maintained library that offers various functional programming utilities.

**Special JS Features/Syntax**

None of the test cases explicitly use any special JavaScript features or syntax. However, it's worth noting that some modern browsers may optimize the performance of these operations using techniques like Just-In-Time (JIT) compilation or ahead-of-time (AOT) compilation.

Latest run results:

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

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

Browser/OS: Chrome 94 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash get	1257614.6 Ops/sec
direct get	5092758.5 Ops/sec
function get	2357944.5 Ops/sec

Related benchmarks:

get lodash perf (version: 0)

asdf

Comparing performance of: lodash get vs direct get vs function get

Created: 8 years ago by: Guest

Jump to the latest result

lodash get

direct get

function get

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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