Benchmark: switch-case vs prepared map

Script Preparation code:

window.map = {
    "first": "1",
    "second": "2",
    "third": "3",
    "forth": "4",
    "fifth": "5",
    "sixth": "6",
    "seventh": "7",
    "eighth": "8",
    "nineth": "9",
    "tenth": 10
};

window.values = ["first", "second", "third", "forth", "fifth", "sixth", "seventh", "eighth", "nineth", "tenth"];

Tests:

Switch Case
const { map, values } = window; function resolve(value) { switch (value) { case "first": return "1"; case "second": return "2"; case "third": return "3"; case "forth": return "4"; case "five": return "5"; case "sixth": return "6"; case "seventh": return "7"; case "eighth": return "8"; case "nineth": return "9"; case "tenth": return "10"; } } for (let i=0; i < values.length; i++) { resolve(values[i]); }
Map
const { map, values } = window; function resolve(value) { return map[value]; } for (let i=0; i < values.length; i++) { resolve(values[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Switch Case
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 what's being tested in this benchmark.

**Benchmark Goal**

The goal of this benchmark is to compare the performance of two approaches: using a `switch-case` statement and using an object (specifically, a `map`) to look up values.

**What is being tested?**

In both test cases:

1. A JavaScript function `resolve(value)` is defined.
2. This function is called repeatedly for an array of 10 values (`values`).
3. In the "Switch Case" test case, the `resolve(value)` function uses a `switch-case` statement to look up the value and return a corresponding string.
4. In the "Map" test case, the `resolve(value)` function looks up the value in an object (predefined as `window.map`) using the syntax `map[value]`.

**Options compared**

The two options being compared are:

1. **Switch-case statement**: This approach uses an `if-else` chain to look up values and returns a corresponding string.
2. **Object lookup using bracket notation**: This approach uses an object (predefined as `window.map`) with keys matching the expected values, and looks up the value using the syntax `map[value]`.

**Pros and Cons of each approach**

1. **Switch-case statement**:
	* Pros: Can be more readable for simple cases, easy to understand.
	* Cons: Can be slower due to the overhead of the `switch` statement, and may not scale well for larger numbers of values.
2. **Object lookup using bracket notation**:
	* Pros: Fast and efficient, can handle a large number of values without significant performance degradation.
	* Cons: May require more code to set up the object and define the keys, less readable for some users.

**Library and purpose**

In this benchmark, `window.map` is used as an object with predefined keys. This object is not part of any specific JavaScript library, but rather a simple data structure used for demonstration purposes.

**Special JS feature or syntax**

This benchmark does not use any special JavaScript features or syntax that would be unfamiliar to most developers.

**Other alternatives**

If you were looking for alternative approaches to this benchmark, some options might include:

* Using an array of functions with `call()` method to look up values
* Using a regular expression to match and return values
* Using a library like Lodash or Ramda for functional programming approaches

However, these alternatives are not being tested in this specific benchmark.

Related benchmarks:

switch-case vs prepared map (version: 2)

Comparing performance of: Switch Case vs Map

Created: 3 years ago by: Registered User

Jump to the latest result

Switch Case

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