Benchmark: switch vs object literal benchmark

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

var str = 'abc';
str = str.charAt(Math.floor(Math.random() * 3));
var num = str.charCodeAt(0)
const a = 'a'.charCodeAt(0)
const b = 'b'.charCodeAt(0)
const c = 'c'.charCodeAt(0)
function handle_switch (num) {
  switch (num) {
    case 97: console.log('A'); break;
    case 98: console.log('B'); break;
    case 99: console.log('C'); break;
  }
}
const object = {
  97: function () { console.log('A') },
  98: function () { console.log('B') },
  99: function () { console.log('C') }
}

function handle_object (num) { object[num]() }

Tests:

switch test
handle_switch(num)
object test
handle_object(num)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
switch test
object test

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36

Browser/OS: Chrome 123 on Linux

View result in a separate tab

Test name	Executions per second
switch test	80226.0 Ops/sec
object test	73937.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark being tested compares two different approaches for handling a simple lookup based on a character's ASCII value: using a `switch` statement versus an `object literal` as a lookup table.

### Options Compared

1. **Switch Statement:** 
   - In the `handle_switch(num)` function, a `switch` statement evaluates the ASCII value of a character to determine which console log statement to execute. Each `case` corresponds to a specific character ('a', 'b', or 'c').
   
2. **Object Literal:**
   - The `handle_object(num)` function makes use of an object where the keys are the ASCII values and the values are functions that log their corresponding characters. This allows for a direct lookup, where calling `object[num]()` executes the function associated with the ASCII value.

### Pros and Cons

#### Switch Statement
- **Pros:**
   - Easy to read and understand for simple cases.
   - Well-known syntax for developers familiar with traditional control structures.
- **Cons:**
   - Can become verbose and hard to manage with a large number of cases.
   - The performance may degrade as the number of `case` statements increases, especially if there’s a lot of branching logic or fallback cases.
   - JavaScript engines may have optimizations for switch statements, but the performance can vary based on how many cases there are.

#### Object Literal
- **Pros:**
   - Cleaner and shorter for simple mappings. Adding new mappings is straightforward by just adding new key-value pairs without adding more branches.
   - Potentially faster performance for large datasets since JavaScript engines can optimize property lookups.
   - More flexible in terms of executing functions dynamically.
- **Cons:**
   - For very few cases, the overhead of creating an object might not justify its benefits compared to a simple switch.
   - Slightly less intuitive for developers who expect flow control constructs (like switch) for conditionals.

### Other Considerations
- **Performance:** In the benchmark results, the switch statement executed approximately **80,226** times per second, while the object literal executed **73,937** times per second. The results indicate that the switch statement performed better in this specific benchmark, potentially due to the fact that the lookup in the switch statement was more straightforward.
  
- **Readability vs. Performance:** While readability is essential, performance characteristics of both approaches can vary with larger datasets. Evaluating the trade-offs based on expected use cases can inform which approach is more suitable.

### Alternatives
Other alternatives to achieve similar functionality include:

- **If-Else Chains:** Using a series of `if-else` conditions could serve similar purposes. However, this is generally less efficient than both switch statements and object lookups for multiple conditions.
  
- **Maps:** Using a `Map` instead of a plain object for more complex key-value relationships can be beneficial, especially for large datasets as it provides better performance for dynamic collections and inherits iterable properties.
  
- **Function Mapping:** For actions that may require complex processing beyond mere logging, higher-order functions or classes can encapsulate behavior and state, though this might introduce additional complexity.

In summary, both the `switch` statement and `object literal` have their place in JavaScript development, and the context of their use cases—balancing between readability, maintainability, and performance—will guide developers in choosing the appropriate approach for their specific situations.

Related benchmarks:

switch vs object literal benchmark (version: 1)

switch vs object literal benchmark

Comparing performance of: switch test vs object test

Created: one year ago by: Guest

Jump to the latest result

switch test

object test

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):