Benchmark: Object Lookup - MeasureThat.net

Script Preparation code:

var CONSTANTS = {
  codes: {
    error: {
      404: 'Not Found',
    },
    success: {
      200: 'Okay',
    },
  },
};

Tests:

Global
function global () { return { success : CONSTANTS.codes.success, error : CONSTANTS.codes.error, }; } global();
Local
function local (constants) { return { success : constants.codes.success, error : constants.codes.error, }; } local(CONSTANTS);
Destructuring Global
function destructuringGlobal () { const { success, error } = CONSTANTS.codes; return { success : success, error : error, }; } destructuringGlobal();
Destructuring Local
function destructuringLocal (constants) { const { success, error } = constants.codes; return { success : success, error : error, }; } destructuringLocal(CONSTANTS);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Global
Local
Destructuring Global
Destructuring Local

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, the options compared, and their pros and cons.

**Benchmark Overview**

The Object Lookup benchmark tests the performance of JavaScript engines when accessing object properties using different methods: global variable access, local variable access, destructuring assignment, and a combination of both (destructuring global).

**Options Compared**

1. **Global Variable Access**: `global()` function returns an object with two properties: `success` and `error`, which are accessed directly.
2. **Local Variable Access**: `local(constants)` function takes a constant object as an argument and returns an object with the same properties, which are then accessed using dot notation (`constants.codes.success`).
3. **Destructuring Global**: `destructuringGlobal()` function uses destructuring assignment to extract `success` and `error` values from the `CONSTANTS` object and assigns them directly to the return object.
4. **Destructuring Local**: `destructuringLocal(constants)` function takes a constant object as an argument, extracts `success` and `error` values using destructuring assignment, and assigns them to the return object.

**Pros and Cons**

1. **Global Variable Access**:
	* Pros: Simple and straightforward.
	* Cons: May lead to slower performance due to the need for additional lookups (e.g., `CONSTANTS.error`).
2. **Local Variable Access**:
	* Pros: May be faster since it avoids direct property access on the global object.
	* Cons: Requires passing a constant object as an argument, which may incur overhead.
3. **Destructuring Global**:
	* Pros: May be faster since it avoids dot notation and allows for early binding of variables.
	* Cons: Requires support for destructuring assignment in JavaScript engines.
4. **Destructuring Local**:
	* Pros: Combines the benefits of local variable access and destructuring global, reducing overhead compared to passing a constant object.
	* Cons: May be slower due to the additional lookup required (extracting `success` and `error` values from the constant object).

**Library**

The benchmark uses JavaScript's built-in object and function features, with no external libraries required.

**Special JS Features/Syntax**

This benchmark tests the following JavaScript features:

1. **Destructuring assignment**: Used in `destructuringGlobal()` and `destructuringLocal()` functions to extract values from objects.
2. **Function expressions**: Used to define the `global()`, `local()`, `destructuringGlobal()`, and `destructuringLocal()` functions.

**Other Considerations**

1. **Constant object optimization**: Some JavaScript engines may optimize constant objects, which could affect the benchmark results.
2. **Engine-specific optimizations**: Different engines (e.g., Firefox) might apply different optimizations or features that impact performance.

**Alternatives**

If you'd like to create your own benchmark, consider exploring other methods for accessing object properties, such as:

1. Using `Object.keys()` and indexing into the resulting array.
2. Utilizing `Proxy` objects for dynamic property access.
3. Implementing a custom caching mechanism for frequently accessed properties.

Keep in mind that each approach will have its pros and cons, and you should consider your specific use case and performance requirements when designing your benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (Android 9; Tablet; rv:66.0) Gecko/66.0 Firefox/66.0

Browser/OS: Firefox 66 on Android

View result in a separate tab

Test name	Executions per second
Global	56200012.0 Ops/sec
Local	84662632.0 Ops/sec
Destructuring Global	84534144.0 Ops/sec
Destructuring Local	84491904.0 Ops/sec

Related benchmarks:

Object Lookup (version: 0)

Comparing performance of: Global vs Local vs Destructuring Global vs Destructuring Local

Created: 5 years ago by: Registered User

Jump to the latest result

Global

Local

Destructuring Global

Destructuring Local

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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