Benchmark: Switch vs Object Literal vs If Else vs Map - testing with simpler data

Script Preparation code:

var animal = ["dog", "cat", "cattle", "cheetah"][Math.floor(Math.random() * 4)]

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))
If Else
function test(animal) { if(animal.toLowerCase()==='cat'){ return 'Kitten' } else if(animal.toLowerCase()=='cattle'){ return 'Calf' } else if(animal.toLowerCase()==='cheetah'){ return 'Cub'; } else if(animal.toLowerCase()==='dog'){ return 'Pup'; } return "I don't know that" } console.log(test(animal))
Object Literal defined outside function
var babyAnimal = { cat:'Kitten', cattle:'Calf', cheetah:'Cub', dog:'Pup' } function test(animal) { return babyAnimal[animal] ?? "I don't know that" } console.log(test(animal))
Map
function test(animal) { const map1 = new Map(); map1.set('cat', 'Kitten'); map1.set('cattle', 'Calf'); map1.set('cheetah', 'Cub'); map1.set('dog', 'Pup'); return map1.get(animal) || "I don't know that" } console.log(test(animal))
Map - defined outsid function
const map1 = new Map(); map1.set('cat', 'Kitten'); map1.set('cattle', 'Calf'); map1.set('cheetah', 'Cub'); map1.set('dog', 'Pup'); function test(animal) { return map1.get(animal) || "I don't know that" } console.log(test(animal))

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Switch

214K/s

If Else

210K/s

Object Literal

209K/s

Object Literal defined outside function

195K/s

Map - defined outsid function

194K/s

Map

192K/s

Fastest: Switch (1.1x faster)

View exact numbers

✓ Switch: 214,381 ops/sec
• If Else: 210,257 ops/sec
• Object Literal: 209,219 ops/sec
• Object Literal defined outside function: 194,706 ops/sec
• Map - defined outsid function: 193,642 ops/sec
• Map: 192,480 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Switch
Object Literal
If Else
Object Literal defined outside function
Map
Map - defined outsid function

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0

Browser/OS: Chrome 136 on Mac OS X 10.15.7

View result in a separate tab

Object Literal

452K/s

Switch

447K/s

If Else

439K/s

Map - defined outsid function

425K/s

Map

421K/s

Object Literal defined outside function

413K/s

View exact numbers

Test name	Executions per second
✓ Object Literal	452,251 Ops/sec
Switch	446,540 Ops/sec
If Else	438,591 Ops/sec
Map - defined outsid function	425,103 Ops/sec
Map	421,484 Ops/sec
Object Literal defined outside function	412,901 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain each test case.

**Benchmark Overview**

The benchmark compares four different approaches to look up values in a small dataset: `switch`, `object literal` (also known as bracket notation), `if-else` statement, and `Map`. The goal is to determine which approach is fastest.

**Test Cases**

1. **Switch**
```javascript
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"
  }
}
```
The `switch` statement is used to execute a block of code based on the value of the `animal` variable. The `break` keyword is implied after each `case` clause.

Pros:

* Simple and concise
* Fast execution

Cons:

* Can be slow for large datasets due to the need to fall through multiple cases
* Not suitable for values that don't have a natural ordering (e.g., strings)

2. **Object Literal**
```javascript
function test(animal) {
  var babyAnimal = {
    cat:'Kitten',
    cattle:'Calf',
    cheetah:'Cub',
    dog:'Pup'
  };
  return babyAnimal[animal] ?? "I don't know that";
}
```
This approach uses an object literal to store the lookup values. The `??` operator is used to provide a default value if the key (`animal`) is not present in the object.

Pros:

* Fast execution for small datasets
* Can be extended with additional keys

Cons:

* Requires memory allocation and access to the object's properties
* May have slower performance than other approaches for very large datasets

3. **If-Else**
```javascript
function test(animal) {
  if(animal.toLowerCase()==='cat'){
    return 'Kitten'
  } else if(animal.toLowerCase()=='cattle'){
     return 'Calf'
  } else if(animal.toLowerCase()==='cheetah'){
     return 'Cub'; 
  } else if(animal.toLowerCase()=='dog'){
    return 'Pup';
  } else {
    return "I don't know that";
  }
}
```
This approach uses a series of `if-else` statements to check the value of the `animal` variable and perform the corresponding action.

Pros:

* Simple and easy to understand
* Can be extended with additional conditions

Cons:

* May have slower performance than other approaches due to the need for multiple checks
* Not suitable for values that don't have a natural ordering (e.g., strings)

4. **Map**
```javascript
function test(animal) {
  var map = new Map();
  map.set('cat', 'Kitten');
  map.set('cattle', 'Calf');
  map.set('cheetah', 'Cub');
  map.set('dog', 'Pup');
  return map.get(animal) ?? "I don't know that";
}
```
This approach uses a `Map` object to store the lookup values. The `get()` method is used to retrieve the value associated with the key (`animal`).

Pros:

* Fast execution for small datasets
* Can be extended with additional keys

Cons:

* Requires memory allocation and access to the map's entries
* May have slower performance than other approaches for very large datasets

**Results**

The benchmark results show that `Object Literal` is the fastest approach, followed closely by `Switch`. The `If-Else` statement is slower due to the need for multiple checks. The `Map` approach is also relatively fast but slower than the first two.

Keep in mind that these results are specific to this particular dataset and may vary depending on the size and complexity of the data.

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

Comparing performance of: `Switch vs Object Literal vs If Else vs Object Literal defined outside function vs Map vs Map - defined outsid function`

Created: 4 years ago by: Guest

Go to the latest result

Switch

Object Literal

If Else

Object Literal defined outside function

Map

Map - defined outsid function

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

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

Comparing performance of: Switch vs Object Literal vs If Else vs Object Literal defined outside function vs Map vs Map - defined outsid function

Created: 4 years ago by: Guest

Go to the latest result

Switch

Object Literal

If Else

Object Literal defined outside function

Map

Map - defined outsid function

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

Comparing performance of: `Switch vs Object Literal vs If Else vs Object Literal defined outside function vs Map vs Map - defined outsid function`