Benchmark: 2dArray[a][b] vs getValue(obj, a, b);

Script Preparation code:

arr = new Array(100).fill(null).map((_, i) => new Array(100).fill(null).map((_, j) => i + "," + j));

objA = {};
objB = {};
objs = [objA, objB];

randomValues = new Array(10000).fill(null).map(() => [Math.floor(Math.random()*100), Math.floor(Math.random()*100), objs[Math.floor(Math.random()*2)]]);

function getValue(obj, a , b) {
  if(obj === objA)
    return arr[a][b];
  else
    return arr[b][a];
}

Tests:

Normal access
const [a, b] = randomValues[Math.floor(Math.random()*10000)]; arr[a][b];
Conditional index-swapped access
const [a, b, obj] = randomValues[Math.floor(Math.random()*10000)]; getValue(obj, a, b);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Normal access
Conditional index-swapped access

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Definition**

The benchmark tests two ways to access elements in a 2D array: directly (`arr[a][b]`) and through a conditional function (`getValue(obj, a, b)`). The `getValue` function checks if the object being accessed is `objA` or `objB` and returns the corresponding value from the `arr` array.

**Options Compared**

The benchmark compares two approaches:

1. **Direct access**: Using the index `[a][b]` to access the element directly in the 2D array (`arr[a][b]`).
2. **Conditional access**: Using the `getValue` function to access the element conditionally, where the function checks if the object being accessed is one of the two objects (`objA` or `objB`) and returns the corresponding value.

**Pros and Cons**

* **Direct Access**
	+ Pros: Typically faster and more efficient since it doesn't involve a function call.
	+ Cons: May not work correctly for large arrays, as accessing an array out of bounds can lead to errors.
* **Conditional Access (getValue)** 
	+ Pros: Can handle large arrays and edge cases where the object being accessed is one of the two objects. However, it involves a function call, which may introduce overhead.
	+ Cons: May be slower than direct access due to the function call.

**Library**

The `getValue` function uses an anonymous function (a lambda function) to perform the conditional check. This function takes three arguments (`obj`, `a`, and `b`) and returns the corresponding value from the `arr` array based on the condition.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark.

**Other Considerations**

When writing a benchmark, consider the following:

* Keep your benchmarks simple and focused on the specific aspect you want to test.
* Use meaningful variable names and descriptive comments to make it easier for others (and yourself) to understand the code.
* Make sure to run multiple iterations of each benchmark to get representative results.
* Consider using profiling tools or built-in browser devtools to help analyze performance.

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

* **Using a lookup table**: Instead of using a function like `getValue`, you could precompute the values and store them in an array or object, eliminating the need for a function call.
* **Using a different data structure**: Depending on your specific use case, you might consider using a different data structure, such as a hash map or a quadtree, which could potentially offer better performance for certain types of queries.

Keep in mind that the best approach will depend on the specifics of your application and the requirements of your project.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.229 Whale/2.10.123.42 Safari/537.36

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
Normal access	2431450.8 Ops/sec
Conditional index-swapped access	1713081.9 Ops/sec

Related benchmarks:

2dArray[a][b] vs getValue(obj, a, b); (version: 0)

Conditional 2D Array index-swapped get performance test.

Comparing performance of: Normal access vs Conditional index-swapped access

Created: 3 years ago by: Guest

Jump to the latest result

Normal access

Conditional index-swapped access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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