Benchmark: ramda path vs js dot selector

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js"></script>

Script Preparation code:

var data = {
    "glossary": {
        "title": "example glossary",
		"GlossDiv": {
            "title": "S",
			"GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
					"SortAs": "SGML",
                }
            }
        }
    }
}

Tests:

Ramda path
R.path(['glossary', 'GlossDiv', 'GlossList', 'GlossEntry', 'ID'])(data)
Native path
data.glossary.GlossDiv.GlossList.GlossEntry.ID
Native path with null check
data?.glossary?.GlossDiv?.GlossList?.GlossEntry?.ID

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda path
Native path
Native path with null check

Fastest: N/A

Slowest: N/A

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

Browser/OS: Chrome 91 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Ramda path	2837903.2 Ops/sec
Native path	16670450.0 Ops/sec
Native path with null check	16471182.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared, and the pros/cons of different approaches.

**Benchmark Definition**

The benchmark tests three ways to access a nested object property in JavaScript: using Ramda's `R.path()` function, native JavaScript dot notation (`data.glossary.GlossDiv.GlossList.GlossEntry.ID`), and a variant with null checks (`data?.glossary?.GlossDiv?.GlossList?.GlossEntry?.ID`).

**Comparison**

* **Native Path (`data.glossary.GlossDiv.GlossList.GlossEntry.ID`)**: This method uses the dot notation to access nested properties directly.
	+ Pros:
		- Fast and efficient, as it doesn't require a function call or additional overhead.
		- Can be optimized by the JavaScript engine.
	+ Cons:
		- Can lead to errors if the object structure changes or is not properly initialized.
		- May not work well with dynamic or unstructured data.
* **Ramda's `R.path()` Function (`R.path(['glossary', 'GlossDiv', 'GlossList', 'GlossEntry', 'ID'])`)**: This method uses a function to access nested properties using an array of keys.
	+ Pros:
		- Flexible and adaptable to dynamic or unstructured data.
		- Can be used for more complex path traversals.
	+ Cons:
		- May introduce additional overhead due to the function call and array iteration.
		- Less efficient than native dot notation in some cases.
* **Native Path with Null Check (`data?.glossary?.GlossDiv?.GlossList?.GlossEntry?.ID`)**: This method uses optional chaining (introduced in ECMAScript 2020) to access nested properties while handling null or undefined values.
	+ Pros:
		- Provides a safe way to access nested properties without throwing errors.
		- Can improve performance by avoiding unnecessary function calls.
	+ Cons:
		- May not work in older browsers that don't support optional chaining.
		- Requires careful consideration of when to use it (e.g., in cases where null or undefined values are common).

**Library and Syntax**

The benchmark uses Ramda's `R.path()` function, which is a utility library for functional programming in JavaScript. It provides a concise way to access nested properties in an array-like object.

There is no special JavaScript feature or syntax used in this benchmark. The focus is on comparing different approaches to accessing nested object properties.

**Alternatives**

Other alternatives for accessing nested object properties include:

* Using the bracket notation (`data['glossary']['GlossDiv']['GlossList']['GlossEntry']['ID']`)
* Utilizing a recursive function or loop to access nested properties
* Using a library like Lodash's `get()` function, which provides similar functionality to Ramda's `R.path()`

However, the benchmark focuses on comparing Ramda's `R.path()` with native JavaScript dot notation and its variant with null checks.

Related benchmarks:

ramda path vs js dot selector (version: 0)

ㅇㅇ

Comparing performance of: Ramda path vs Native path vs Native path with null check

Created: 3 years ago by: Guest

Jump to the latest result

Ramda path

Native path

Native path with null check

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