Benchmark: Switch/case vs indexOf

Tests:

switch/case
const elementAction = { a: 1, b: 2, c: 3, }; function func() { switch (true) { case Object.hasOwn(elementAction, 'foo'): return false; case Object.hasOwn(elementAction, 'bar'): return false; case Object.hasOwn(elementAction, 'baz'): return false; case Object.hasOwn(elementAction, 'bazz'): return false; case Object.hasOwn(elementAction, 'fooz'): return false; case Object.hasOwn(elementAction, 'foob'): return false; case Object.hasOwn(elementAction, 'doob'): return false; case Object.hasOwn(elementAction, 'bafz'): return false; case Object.hasOwn(elementAction, 'barz'): return false; case Object.hasOwn(elementAction, 'gas'): return false; case Object.hasOwn(elementAction, 'gaz'): return false; case Object.hasOwn(elementAction, 'daz'): return false; case Object.hasOwn(elementAction, 'dar'): return false; case Object.hasOwn(elementAction, 'har'): return false; case Object.hasOwn(elementAction, 'ooph'): return false; case Object.hasOwn(elementAction, 'phooph'): return false; default: return true; } } func();
Dictionary
const elementAction = { a: 1, b: 2, c: 3, }; const dictionary = [ { key: 'foo', value: () => false, }, { key: 'bar', value: () => false, }, { key: 'baz', value: () => false, }, { key: 'bazz', value: false, }, { key: 'fooz', value: false, }, { key: 'doob', value: false, }, { key: 'bafz', value: false, }, { key: 'barz', value: false, }, { key: 'gas', value: false, }, { key: 'gaz', value: false, }, { key: 'daz', value: false, }, { key: 'dar', value: false, }, { key: 'har', value: false, }, { key: 'ooph', value: false, }, { key: 'phooph', value: false, }, { key: 'foo', value: false, }, ]; function func() { const index = dictionary.indexOf(({ key }) => Object.hasOwn(elementAction, key)); return index > -1 ? dictionary[index].value : true; } func();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
switch/case
Dictionary

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The benchmark compares the performance of two approaches: `switch/case` and using an array (dictionary) with `indexOf`.

**Switch/Case Approach**

In this approach, we use a `switch` statement to check if a property exists in the `elementAction` object. The `case` statements have varying conditions, which are unlikely to be met, making it effectively equivalent to checking each property individually.

*   **Pros:** This approach is easy to understand and implement for developers familiar with `switch/case`. It can be more efficient if the number of properties in `elementAction` is large.
*   **Cons:** The performance may degrade due to the exhaustive search involved. Additionally, this approach requires defining each possible property value, which can become cumbersome as the number of properties increases.

**Dictionary Approach**

In this approach, we use an array (`dictionary`) with objects containing a key and a value function. We then use `indexOf` to find the index of the first object in the dictionary where the key exists.

*   **Pros:** This approach is concise and easy to maintain if new properties are added to `elementAction`. It can be more efficient for large numbers of properties since only the relevant objects need to be checked.
*   **Cons:** The performance may degrade due to the overhead of searching an array. Additionally, this approach requires defining a value function for each property, which can become complex as the number of properties increases.

**Comparison and Considerations**

When choosing between these approaches, consider the following:

1.  **Performance**: If you anticipate dealing with a large number of properties in `elementAction`, the dictionary approach might be more efficient.
2.  **Code Maintainability**: If new properties are frequently added to `elementAction`, the dictionary approach is easier to maintain.

**Other Alternatives**

There are other approaches that can be used to check if a property exists in an object:

*   **`in` operator**: This operator checks if a property exists directly in the object. It might offer better performance than exhaustive searches.
*   **Property access with `hasOwnProperty`**: While not as concise as using `in`, this approach also checks for property existence.

However, these alternatives may be less familiar or more complex to implement than the switch/case and dictionary approaches.

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Windows NT 5.1; rv:52.0) Gecko/20100101 Firefox/52.0

Browser/OS: Firefox 52 on Windows XP

View result in a separate tab

Test name	Executions per second
switch/case	0.0 Ops/sec
Dictionary	98659.8 Ops/sec

Related benchmarks:

Switch/case vs indexOf (version: 0)

Comparing performance of: switch/case vs Dictionary

Created: 3 months ago by: Guest

Jump to the latest result

switch/case

Dictionary

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