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"];

​x
 
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]);
}

 
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]);
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Switch Case
Map

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
Switch Case	11187048.0 Ops/sec
Map	6873633.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

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:

A JavaScript function resolve(value) is defined.
This function is called repeatedly for an array of 10 values (values).
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.
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:

Switch-case statement: This approach uses an if-else chain to look up values and returns a corresponding string.
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

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.
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.

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: 2 years ago by: Registered User

Jump to the latest result