Benchmark: Switch vs Object Literal - testing with simpler data

Script Preparation code:

var animal = "dog"

Tests:

Switch
function test(animal) { switch(animal){ case 'cat': return 'Kitten' case 'cattle': return 'Calf' case 'cheetah': return 'Cub' case 'dog': return 'Pup' default: return "I don't know that" } } console.log(test(animal))
Object Literal
function test(animal) { var babyAnimal = { cat:'Kitten', cattle:'Calf', cheetah:'Cub', dog:'Pup' } return babyAnimal[animal] ?? "I don't know that" } console.log(test(animal))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Switch
Object Literal

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.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and results.

**Benchmark Definition**

The benchmark is called "Switch vs Object Literal - testing with simpler data". It consists of two test cases:

1. **"Switch"**: This test case uses a `switch` statement to determine which baby animal to return based on the input `animal`. The `switch` statement checks the value of `animal` and returns a corresponding string (e.g., "Kitten" for "cat").
2. **"Object Literal"**: This test case uses an object literal (`var babyAnimal = {...}`) to store mappings between animal names and their corresponding baby animals. It then looks up the value in the object using the input `animal` as a key, returning the corresponding string (e.g., "Kitten" for "cat").

**Script Preparation Code**

The script preparation code sets a variable `animal` to the value `"dog"`.

**Test Cases**

Each test case has two parts:

1. **Benchmark Definition**: A JavaScript function that defines the test case's behavior.
2. **Test Name**: The name of the test case (either "Switch" or "Object Literal").

The benchmark definition code for each test case is as follows:
```javascript
// Switch
function test(animal) {
  switch(animal){
    case 'cat': return 'Kitten'
    case 'cattle': return 'Calf'
    case 'cheetah': return 'Cub'
    case 'dog': return 'Pup'
    default: return "I don't know that"
  }
}

// Object Literal
function test(animal) {
  var babyAnimal = {
    cat:'Kitten',
    cattle:'Calf',
    cheetah:'Cub',
    dog:'Pup'
  }

return babyAnimal[animal] ?? "I don't know that"
}
```
**Latest Benchmark Result**

The results show two test cases:

1. **"Switch"**: The `switch` statement has an execution speed of approximately 47,939 executions per second.
2. **"Object Literal"**: The object literal approach has an execution speed of approximately 43,926 executions per second.

**Comparison and Analysis**

The benchmark compares the performance of two approaches:

1. **Switch statement**: A traditional `switch` statement that uses a series of `if-else` statements under the hood.
2. **Object Literal**: An object literal approach that uses a hash table to store mappings between keys and values.

**Pros and Cons:**

* **Switch Statement**:
	+ Pros: Easy to read and write, good for simple cases.
	+ Cons: Can become cumbersome for large numbers of cases.
* **Object Literal**:
	+ Pros: Flexible, easy to add or remove key-value pairs.
	+ Cons: May be slower due to the overhead of hash table lookups.

**Library Used**

No external libraries are used in this benchmark.

**JS Feature or Syntax**

The test cases use JavaScript's `switch` statement and object literals. The `??` operator (optional chaining) is also used in the object literal approach, which is a newer syntax introduced in ECMAScript 2020.

**Alternatives**

Other alternatives to consider:

* **If-else chain**: A traditional series of `if-else` statements.
* **Hash table with lookup functions**: A custom hash table implementation with separate functions for lookups and updates.
* **Switch statement with `default` case**: Adding a default case to the switch statement can improve performance by avoiding unnecessary checks.

Related benchmarks:

Switch vs Object Literal - testing with simpler data (version: 0)

Comparing performance of: Switch vs Object Literal

Created: 4 years ago by: Guest

Jump to the latest result

Switch

Object Literal

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):