Benchmark: Switch vs map with string keys and early exit

Script Preparation code:

var runSwitch = input =>   {
  switch(input) {
    case 'one':
      return true;
    case 'two':
      return true;
    case 'three':
      return true;
    case 'four':
      return true;
     case 'five':
      return true;
    case 'six':
      return true;
    case 'seven':
      return true;
    case 'eight':
      return true;
      case 'nine':
      return true;
    case 'ten':
      return true;
  }
}

var LUT = {
	zero: true,
  one: true,
  two: true,
  three: true,
  four: true,
  five: true,
  six: true,
  seven: true,
  eight: true,
  nine: true,
  ten: true
}

var input = 'five';

Tests:

Switch
runSwitch(input);
Map
LUT[input];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Switch
Map

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 break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark defines two functions: `runSwitch` and `LUT[input]`. The latter is likely a typo, but it appears to be a lookup table (`LUT`) with key-value pairs, where each value is set to `true`.

Here's what the script preparation code shows:

*   `var runSwitch = input => { ... }`: This defines an anonymous function named `runSwitch` that takes an `input` parameter. The function contains a `switch` statement that returns `true` for each of the 10 cases (e.g., `'one'`, `'two'`, etc.). This suggests that the benchmark is testing the performance of the `switch` statement in JavaScript.
*   `var LUT = { ... }`: This defines an object (`LUT`) with key-value pairs, where each key is a string and each value is set to `true`. The purpose of this lookup table is unclear without more context.

**Options Compared**

The benchmark compares the performance of two approaches:

1.  **Switch Statement**: This option uses the `switch` statement in the `runSwitch` function.
2.  **Lookup Table (Map)**: This option uses the `LUT[input]` expression, which appears to be a lookup operation using the object `LUT`.

**Pros and Cons of Each Approach**

*   **Switch Statement**:
    *   Pros:
        *   More readable code
        *   Can handle more complex cases with multiple branches
    *   Cons:
        *   May be slower than lookup tables for large numbers of keys
*   **Lookup Table (Map)**:
    *   Pros:
        *   Fast performance, especially for large datasets
        *   Memory-efficient
    *   Cons:
        *   Less readable code
        *   Requires manual management of key-value pairs

**Library and Special JS Features**

There are no libraries explicitly mentioned in the benchmark definition. However, the `LUT[input]` expression uses a feature called "computed property access" (introduced in ECMAScript 2015) to dynamically access properties of an object using a string as the key.

**Other Considerations**

*   The benchmark uses Chrome 69 as the browser, which may limit its applicability to other browsers or versions.
*   The benchmark is run on a desktop platform with Mac OS X 10.13.6, which may also affect its generality.

**Alternatives**

Some alternative approaches could be considered:

1.  **Using `Object.keys()` and `Array.prototype.forEach()`**: This approach would involve iterating over the keys of the `LUT` object using `Object.keys()`, and then applying a callback function to each key using `Array.prototype.forEach()`. While this approach avoids the computed property access, it may be slower than the lookup table approach.
2.  **Using a library like Lodash's `get()`**: This approach would involve using a library like Lodash that provides a `get()` function for accessing properties of an object dynamically. However, this would require including an external dependency and may not offer significant performance benefits.

In summary, the benchmark definition tests the performance of two approaches: the `switch` statement in JavaScript and a lookup table (map) using computed property access. The choice between these approaches depends on factors like code readability, performance requirements, and the specific use case.

Related benchmarks:

Switch vs map with string keys and early exit (version: 0)

Comparing performance of: Switch vs Map

Created: 7 years ago by: Guest

Jump to the latest result

Switch

Map

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