Benchmark: path functions - MeasureThat.net

Script Preparation code:

var path = (keys, is = "return " + keys.reduce((values, key) => values + "['"+ key +"']", "value")) => new Function("value", is)
var path2 = keys => value => keys.reduce((value, key) => value[key], value);
var keys = Array.from({ length: 100 }, (_, i) => "a" + i);
var i = 65535;
var test = {};
var tmp;
while(i--) {
    tmp = test;
    test = { ["a" + i]: tmp };
}
var run1 = path(keys);
var run2 = path2(keys);
i = 1000000;
while (i--) {
	run1(Object.setPrototypeOf({ i }, test));
	run2(Object.setPrototypeOf({ i }, test));
}

Tests:

new f
run1(test);
reduce
run2(test);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new f
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
new f	3235152.2 Ops/sec
reduce	766352.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark JSON and explore what's being tested.

**Benchmark Definition**

The benchmark defines two test cases, `new f` and `reduce`, which are executed using two different functions: `path` and `path2`. These functions seem to be creating new functions that manipulate JavaScript objects.

**What is being tested?**

In this case, the benchmark is testing the performance of two approaches for creating functions that perform array-like operations on JavaScript objects. Specifically:

*   `run1(test)`: This function uses the `path` approach, which creates a new function by concatenating an array of keys into a string and then wrapping it around the `value` parameter.
*   `run2(test)`: This function uses the `path2` approach, which also creates a new function but does so in a different way using the `reduce` method.

**Options Compared**

The two approaches being tested are:

*   `path` (using `concat` and `Function`)
*   `path2` (using `reduce`)

Pros and Cons of Each Approach:

*   **Path**: 
    *   Pros:
        *   Simple to implement
        *   May be more readable for some developers
    *   Cons:
        *   Less efficient than the `path2` approach due to the overhead of creating a new function using `Function`
*   **Path2** (using `reduce`):
    *   Pros:
        *   More efficient than the `path` approach
        *   Uses a more modern JavaScript feature (`reduce`) and is thus easier to understand for many developers
    *   Cons:
        *   May be less readable for some developers due to its use of `reduce`

**Library/ Syntax Used**

*   No external libraries are used in this benchmark.
*   The test cases use special JavaScript syntax:
    +   `Function` constructor (used in the `path` approach)
    +   `reduce` method (used in the `path2` approach)

The `path` function uses the `Function` constructor to create a new function, which is an older way of creating functions in JavaScript. This might make it less readable for some developers.

On the other hand, the `path2` function uses the `reduce` method to achieve a similar result, making it easier to understand and more idiomatic for modern JavaScript.

**Other Alternatives**

There are many other ways to create functions that perform array-like operations on JavaScript objects. Some alternatives could include:

*   Using a library like Lodash or Underscore.js
*   Implementing a custom function creation mechanism using template literals or other string manipulation techniques

However, these alternatives might not be as straightforward to understand for developers who are familiar with the `path` and `path2` approaches.

Overall, the benchmark is testing the performance of two different approaches to creating functions that manipulate JavaScript objects. The `path2` approach appears to be more efficient and uses modern syntax, making it a good candidate for production use cases.

Related benchmarks:

path functions (version: 0)

Comparing performance of: new f vs reduce

Created: one year ago by: Guest

Jump to the latest result

new f

reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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