Benchmark: Object vs Switch..Case vs Map

Tests:

Object

const obj = {
	one: 'One',
  	two: 'Two',
  	three: 'Three',
};

const result = obj.three;
console.log(result);

​x
 
const obj = {    one: 'One',    two: 'Two',    three: 'Three',};​const result = obj.three;console.log(result);

Switch..case

const input = 'three';
let result;

switch (input) {
  case 'one': {
    result = 'One';
  }
  case 'two': {
    result = 'Two';
  }
  case 'three': {
    result = 'Three';
  }
}

console.log(result);

 
const input = 'three';let result;​switch (input) {  case 'one': {    result = 'One';  }  case 'two': {    result = 'Two';  }  case 'three': {    result = 'Three';  }}​console.log(result);

Map

const values = new Map([
  ["one", 'One'],
  ["two", 'Two'],
  ["three", 'Three']
]);

const result = values.get('three');

console.log(result);

 
const values = new Map([  ["one", 'One'],  ["two", 'Two'],  ["three", 'Three']]);​const result = values.get('three');​console.log(result);

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
Object
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/107.0.0.0 Safari/537.36

Browser/OS: Chrome 107 on Windows

View result in a separate tab

Test name	Executions per second
Object	284896.4 Ops/sec
Switch..case	280989.2 Ops/sec
Map	238451.4 Ops/sec

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

Let's break down the benchmark and explain what's being tested.

Benchmark Definition

The provided JSON defines a benchmark with three test cases:

Object: Tests access to a property on an object using dot notation (obj.three).
Switch..case: Tests switch-case statements to find the value of a variable that matches one of several possible values.
Map: Tests accessing a value from a Map data structure using the get() method.

Options being compared

The benchmark is comparing three approaches:

Dot notation on an object (Object)
Switch-case statements (Switch..case)
Map data structures with the get() method (Map)

These options are being compared in terms of execution speed and performance.

Pros and Cons of each approach:

Dot notation on an object:
- Pros: Simple, widely supported, and intuitive.
- Cons: Can be slower due to string interpolation and property access overhead.
Switch-case statements:
- Pros: Can be faster for multiple value checks, especially with large datasets.
- Cons: Requires explicit case checking and can lead to code bloat if not optimized.
Map data structures with get() method:
- Pros: Fast lookups and efficient memory usage, especially for large datasets.
- Cons: May require additional setup (e.g., creating the Map) and understanding of the data structure.

Library/JS feature explanation

None mentioned in this benchmark definition. However, note that JavaScript features like ES6 classes or async/await might be used elsewhere in the test cases.

Test case analysis

Each test case is designed to exercise a specific aspect of each approach:

Object: Tests direct property access on an object.
Switch..case: Verifies switch-case execution for multiple value checks.
Map: Demonstrates fast lookups using the get() method.

Other alternatives

Considering alternative approaches, you might also want to test:

Array methods like indexOf() or find()
Other data structures like arrays or binary search trees
Caching mechanisms (e.g., LRU cache) for performance optimizations

Keep in mind that this benchmark is focused on basic property access, switch-case execution, and Map lookups. Additional tests could explore more complex scenarios, such as:

Array iteration or searching
Object creation and manipulation
More advanced switch-case cases (e.g., multiple conditions with fallthrough)
Using async/await or promises for asynchronous operations

Feel free to ask if you have any further questions!

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The provided JSON defines a benchmark with three test cases:

1. **Object**: Tests access to a property on an object using dot notation (`obj.three`).
2. **Switch..case**: Tests switch-case statements to find the value of a variable that matches one of several possible values.
3. **Map**: Tests accessing a value from a Map data structure using the `get()` method.

**Options being compared**

The benchmark is comparing three approaches:

* Dot notation on an object (Object)
* Switch-case statements (Switch..case)
* Map data structures with the `get()` method (Map)

These options are being compared in terms of execution speed and performance.

**Pros and Cons of each approach:**

1. **Dot notation on an object**:
	* Pros: Simple, widely supported, and intuitive.
	* Cons: Can be slower due to string interpolation and property access overhead.
2. **Switch-case statements**:
	* Pros: Can be faster for multiple value checks, especially with large datasets.
	* Cons: Requires explicit case checking and can lead to code bloat if not optimized.
3. **Map data structures with `get()` method**:
	* Pros: Fast lookups and efficient memory usage, especially for large datasets.
	* Cons: May require additional setup (e.g., creating the Map) and understanding of the data structure.

**Library/JS feature explanation**

None mentioned in this benchmark definition. However, note that JavaScript features like ES6 classes or async/await might be used elsewhere in the test cases.

**Test case analysis**

Each test case is designed to exercise a specific aspect of each approach:

1. **Object**: Tests direct property access on an object.
2. **Switch..case**: Verifies switch-case execution for multiple value checks.
3. **Map**: Demonstrates fast lookups using the `get()` method.

**Other alternatives**

Considering alternative approaches, you might also want to test:

* Array methods like `indexOf()` or `find()`
* Other data structures like arrays or binary search trees
* Caching mechanisms (e.g., LRU cache) for performance optimizations

Keep in mind that this benchmark is focused on basic property access, switch-case execution, and Map lookups. Additional tests could explore more complex scenarios, such as:

* Array iteration or searching
* Object creation and manipulation
* More advanced switch-case cases (e.g., multiple conditions with fallthrough)
* Using async/await or promises for asynchronous operations

Feel free to ask if you have any further questions!

Related benchmarks:

Object vs Switch..Case vs Map (version: 0)

Comparing performance of: Object vs Switch..case vs Map

Created: 4 years ago by: Guest

Jump to the latest result