Benchmark: safeGet comparison (PR)

Script Preparation code:

var state = {
  wrapped1: {
    wrapped2: {
      location: {
    	search: '',
    	id: 12
      }
    }
  },
  data: {}
};

var safeGet = function(nestedObj, paths, defaultVal) {
  if (!paths || paths.length === 0) return defaultVal
  const result = paths.slice(0).reduce((obj, path, i, arr) => {
    if (!obj) {
      arr.splice(i) // break out of the loop
      return undefined
    }
    return obj[path]
  }, nestedObj)

  if (result === undefined || result === null) {
    return defaultVal
  }

  return result
}
var safeGet2 = function(nestedObj, paths, defaultVal) {
  if (!paths || paths.length === 0) return defaultVal
  for (let p = 0; p < paths.length; p++) {
    nestedObj = nestedObj ? nestedObj[paths[p]] : undefined
  }
  return nestedObj === undefined || nestedObj === null ? defaultVal : nestedObj
}
var safeGet3 = function(nestedObj, paths, defaultVal, p, undef) {
  if (!paths || paths.length === 0) return defaultVal
  for (p = 0; p < paths.length; p++) {
    nestedObj = nestedObj ? nestedObj[paths[p]] : undef
  }
  return nestedObj === undef || nestedObj === null ? defaultVal : nestedObj
}

var dlv = function(obj, key, def, p, undef) {
	key = key.split ? key.split('.') : key;
	for (p = 0; p < key.length; p++) {
		obj = obj ? obj[key[p]] : undef;
	}
	return obj === undef ? def : obj;
}

Tests:

Optional chaining (babel es2015)
var _state$wrapped, _state$wrapped$wrappe, _state$wrapped$wrappe2; var s = state === null || state === void 0 ? void 0 : (_state$wrapped = state.wrapped1) === null || _state$wrapped === void 0 ? void 0 : (_state$wrapped$wrappe = _state$wrapped.wrapped2) === null || _state$wrapped$wrappe === void 0 ? void 0 : (_state$wrapped$wrappe2 = _state$wrapped$wrappe.location) === null || _state$wrapped$wrappe2 === void 0 ? void 0 : _state$wrapped$wrappe2.search;
old safeGet
var l = safeGet(state, ['wrapped1','wrapped2','location','search']);
dlv (array notation)
dlv(state, ['wrapped1','wrapped2','location','search']);
safeGet not using variables as params
safeGet2(state, ['wrapped1','wrapped2','location','search']);
safeGet not using variables as params (this PR code)
safeGet3(state, ['wrapped1','wrapped2','location','search']);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Optional chaining (babel es2015)
old safeGet
dlv (array notation)
safeGet not using variables as params
safeGet not using variables as params (this PR code)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what is being tested.

**Overview**

The benchmark compares four different approaches to safely access nested object properties:

1. `safeGet` (version 1)
2. `safeGet2`
3. `safeGet3`
4. `dlv` (a function that uses array notation)

These functions aim to provide a safe way to access nested object properties, avoiding null pointer exceptions or undefined values.

**Options being compared**

The benchmark compares the performance of each approach:

* **`safeGet` (version 1)**: This function uses an iterative approach to traverse the object graph. It checks if the current property exists and breaks out of the loop if it doesn't.
* **`safeGet2`**: This function uses a similar approach as `safeGet` but without using variables as parameters.
* **`safeGet3`**: Similar to `safeGet`, but with an additional variable `p` used to keep track of the current property index.
* **`dlv` (array notation)**: This function uses array notation (`[]`) to access nested object properties. It's designed to be more concise and expressive than the other approaches.

**Pros and Cons**

Here are some pros and cons for each approach:

* **`safeGet` (version 1)**:
	+ Pros: Simple, easy to understand.
	+ Cons: May have performance overhead due to the loop.
* **`safeGet2`**:
	+ Pros: Similar to `safeGet`, but with less code.
	+ Cons: May be slightly slower than `safeGet`.
* **`safeGet3`**:
	+ Pros: Same as `safeGet`, but with an additional variable `p` for better performance.
	+ Cons: May be harder to understand due to the extra complexity.
* **`dlv` (array notation)**:
	+ Pros: Concise, expressive, and potentially faster than the other approaches.
	+ Cons: May not be as easy to understand or debug.

**Device and Browser Variations**

The benchmark runs on different devices and browsers with varying OS versions. The results are affected by factors such as:

* **DevicePlatform**: Desktop vs. non-Desktop environments may exhibit differences in performance.
* **OperatingSystem**: Different OS versions (e.g., Mac OS X 10.15.7) might influence the execution speed.
* **Browser**: Chrome 103 is used for all tests, which may impact performance due to specific browser optimizations or limitations.

**Conclusion**

The benchmark aims to compare the performance of four approaches to safely access nested object properties. The results will help determine which approach is most efficient and suitable for a given use case.

Related benchmarks:

safeGet comparison (PR) (version: 0)

Comparing performance of: Optional chaining (babel es2015) vs old safeGet vs dlv (array notation) vs safeGet not using variables as params vs safeGet not using variables as params (this PR code)

Created: 3 years ago by: Guest

Jump to the latest result

Optional chaining (babel es2015)

old safeGet

dlv (array notation)

safeGet not using variables as params

safeGet not using variables as params (this PR code)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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