Benchmark: another approach to Switch vs Object Literal

Script Preparation code:

var str = 'abc';
str = str.charAt(Math.floor(Math.random() * 3));

AخA
 
var str = 'abc';str = str.charAt(Math.floor(Math.random() * 3));

Tests:

Switch

const useSwitch = (str) => {
  switch (str) {
    case 'a': return 'A'; break
    case 'b': return 'B'; break
    case 'c': return 'C'; break
  }
}

console.log(useSwitch(str));

​x
 
const useSwitch = (str) => {  switch (str) {    case 'a': return 'A'; break    case 'b': return 'B'; break    case 'c': return 'C'; break  }}​console.log(useSwitch(str));

Object property

const useObject = (str) => {

  let letters = {
    a: 'A',
    b: 'B',
    c: 'C'
  }

  return letters[str]
}

console.log(useObject(str));

 
const useObject = (str) => {​  let letters = {    a: 'A',    b: 'B',    c: 'C'  }​  return letters[str]}​console.log(useObject(str));

Object with arrow funcion
var arrow = { a: () => 'A', b: () => 'B', c: () => 'C' } console.log(arrow[str]());
var arrow = {

a: () => 'A',
b: () => 'B',
c: () => 'C'

}

console.log(arrow[str]());
Object with funcion (from the link in description)
var objLiteral = { a: function() { console.log('A'); }, b: function() { console.log('B'); }, c: function() { console.log('C'); } } objLiteral[str]();
var objLiteral = {
a: function() {
console.log('A');
},
b: function() {
console.log('B');
},
c: function() {
console.log('C');
}
}

objLiteral[str]();

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
Object property
Object with arrow funcion
Object with funcion (from the link in description)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 9; SM-N9600) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.93 Mobile Safari/537.36

Browser/OS: Chrome Mobile 79 on Android

View result in a separate tab

Test name	Executions per second
Switch	59416.1 Ops/sec
Object property	58909.7 Ops/sec
Object with arrow funcion	55503.1 Ops/sec
Object with funcion (from the link in description)	57313.0 Ops/sec

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

Let's break down the provided benchmark JSON and explain what's being tested, compared, and discussed.

Benchmark Purpose: The benchmark compares four approaches to access a value stored in an array or object:

Using a switch statement
Accessing an object property using bracket notation (str['a'], etc.)
Using an object with arrow functions (e.g., arrow[str]())
Using an object with traditional function expressions (e.g., objLiteral[str]())

The benchmark aims to evaluate the performance of these four approaches on a JavaScript engine.

Comparison Options: The benchmark compares the execution speed of each approach using various browsers and devices, including Chrome Mobile 79 running on Android 9. The comparison options are:

Execution speed (ExecutionsPerSecond) in the number of executions per second
Browser type and version
Device platform and operating system

Pros and Cons:

Switch statement: Pros: Simple, concise syntax; Cons: May have performance overhead due to branching.
Object property access: Pros: Fast, efficient; Cons: May be slower than switch statements for large numbers of cases.
Object with arrow functions: Pros: Concise, modern syntax; Cons: May have compatibility issues in older browsers or environments.
Object with traditional function expressions: Pros: Widely supported and compatible; Cons: May be less concise than other approaches.

Library Usage: None of the benchmark test cases use external libraries. The useSwitch and objLiteral functions rely on built-in JavaScript features, while useObject uses an object literal with bracket notation to access the property.

Special JS Features or Syntax: None of the test cases use special JavaScript features like ES6 modules, async/await, or Promises. The focus is on evaluating the performance of basic syntax elements.

Alternatives: If you're interested in exploring alternative approaches, here are some options:

Use a different browser or device platform to compare performance
Experiment with other languages or engines (e.g., Node.js, TypeScript)
Test additional features or optimizations (e.g., caching, parallel execution)
Explore more complex scenarios or edge cases

By analyzing the benchmark's structure and comparison options, you can gain insights into the performance characteristics of each approach and make informed decisions about which syntax to use in your own JavaScript applications.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explain what's being tested, compared, and discussed.

**Benchmark Purpose:**
The benchmark compares four approaches to access a value stored in an array or object:

1. Using a `switch` statement
2. Accessing an object property using bracket notation (`str['a']`, etc.)
3. Using an object with arrow functions (e.g., `arrow[str]()`)
4. Using an object with traditional function expressions (e.g., `objLiteral[str]()`)

The benchmark aims to evaluate the performance of these four approaches on a JavaScript engine.

**Comparison Options:**
The benchmark compares the execution speed of each approach using various browsers and devices, including Chrome Mobile 79 running on Android 9. The comparison options are:

* Execution speed (ExecutionsPerSecond) in the number of executions per second
* Browser type and version
* Device platform and operating system

**Pros and Cons:**

* **Switch statement**: Pros: Simple, concise syntax; Cons: May have performance overhead due to branching.
* **Object property access**: Pros: Fast, efficient; Cons: May be slower than switch statements for large numbers of cases.
* **Object with arrow functions**: Pros: Concise, modern syntax; Cons: May have compatibility issues in older browsers or environments.
* **Object with traditional function expressions**: Pros: Widely supported and compatible; Cons: May be less concise than other approaches.

**Library Usage:**
None of the benchmark test cases use external libraries. The `useSwitch` and `objLiteral` functions rely on built-in JavaScript features, while `useObject` uses an object literal with bracket notation to access the property.

**Special JS Features or Syntax:**
None of the test cases use special JavaScript features like ES6 modules, async/await, or Promises. The focus is on evaluating the performance of basic syntax elements.

**Alternatives:**
If you're interested in exploring alternative approaches, here are some options:

* Use a different browser or device platform to compare performance
* Experiment with other languages or engines (e.g., Node.js, TypeScript)
* Test additional features or optimizations (e.g., caching, parallel execution)
* Explore more complex scenarios or edge cases

Related benchmarks:

another approach to Switch vs Object Literal (version: 1)

Another approach to this test: https://www.measurethat.net/Benchmarks/Show/3444/0/switch-vs-object-literal

Comparing performance of: Switch vs Object property vs Object with arrow funcion vs Object with funcion (from the link in description)

Created: 5 years ago by: Registered User

Jump to the latest result