Benchmark: Switch vs Functional Approach

Tests:

Vanilla Switch

function isFunc (v) {
  return typeof v === 'function';
}

function isDefined (v)  {
  return v !== undefined && v !== null;
}

function switchEnum(e, handlers) {
  const specific = handlers[e];
  if (isDefined(specific)) {
    return isFunc(specific) ? specific(e) : specific;
  }

  if (isDefined(handlers.else)) {
    return isFunc(handlers.else) ? handlers.else(e) : handlers.else;
  }

  throw new Error(`Unhandled switchEnum statement for value (${e}).`);
}

function normal(inp) {
  switch (inp) {
    case "today":
      return 1;
    case "tomorrow":
      return 2;
    case "yesterday":
      return -1;
    default:
      return 0;	
  }
};

normal('today');
normal('yesterday');
normal('tomorrow');

​x
 
function isFunc (v) {  return typeof v === 'function';}​function isDefined (v)  {  return v !== undefined && v !== null;}​function switchEnum(e, handlers) {  const specific = handlers[e];  if (isDefined(specific)) {    return isFunc(specific) ? specific(e) : specific;  }​  if (isDefined(handlers.else)) {    return isFunc(handlers.else) ? handlers.else(e) : handlers.else;  }​  throw new Error(`Unhandled switchEnum statement for value (${e}).`);}​function normal(inp) {  switch (inp) {    case "today":      return 1;    case "tomorrow":      return 2;    case "yesterday":      return -1;    default:      return 0;   }};​normal('today');normal('yesterday');normal('tomorrow');

Switch Fn style

function isFunc (v) {
  return typeof v === 'function';
}

function isDefined (v)  {
  return v !== undefined && v !== null;
}

function switchEnum(e, handlers) {
  const specific = handlers[e];
  if (isDefined(specific)) {
    return isFunc(specific) ? specific(e) : specific;
  }

  if (isDefined(handlers.else)) {
    return isFunc(handlers.else) ? handlers.else(e) : handlers.else;
  }

  throw new Error(`Unhandled switchEnum statement for value (${e}).`);
}

function funcccy(inp) {
 return switchEnum(inp, {
   "today": () => 1,
   "tomorrow": () => 2,
   "yesterday": () => -1,
   "else": () => 0,
  });
}
funcccy('today');
funcccy('yesterday');
funcccy('tomorrow');

 
function isFunc (v) {  return typeof v === 'function';}​function isDefined (v)  {  return v !== undefined && v !== null;}​function switchEnum(e, handlers) {  const specific = handlers[e];  if (isDefined(specific)) {    return isFunc(specific) ? specific(e) : specific;  }​  if (isDefined(handlers.else)) {    return isFunc(handlers.else) ? handlers.else(e) : handlers.else;  }​  throw new Error(`Unhandled switchEnum statement for value (${e}).`);}​function funcccy(inp) { return switchEnum(inp, {   "today": () => 1,   "tomorrow": () => 2,   "yesterday": () => -1,   "else": () => 0,  });}funcccy('today');funcccy('yesterday');funcccy('tomorrow');

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
Vanilla Switch
Switch Fn style

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0

Browser/OS: Firefox 125 on Windows

View result in a separate tab

Test name	Executions per second
Vanilla Switch	63907816.0 Ops/sec
Switch Fn style	8259009.5 Ops/sec

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

Benchmark Explanation

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares two approaches: the traditional switch statement and a functional programming style using a callback function.

Traditional Switch Statement (Vanilla Switch)

The traditional switch statement is compared to its functional equivalent. In this case, both test cases use the same code structure:

Define a set of handlers with values as keys and functions as values.
Use the switch statement to select the corresponding handler based on the input value.
Call the selected function with the input value as an argument.

In the vanilla switch test case, the normal function is called with different input values: "today", "yesterday", and "tomorrow".

Functional Approach (Switch Fn style)

The functional approach uses a callback function to achieve the same result:

Define a set of handlers with values as keys and functions as values.
Use a closure to capture the handlers object and create a new function funcccy that takes an input value.
Within funcccy, call the switchEnum function with the input value and the handlers object.

In this test case, the funcccy function is called with different input values: "today", "yesterday", and "tomorrow".

Comparison

The comparison between these two approaches aims to measure which one performs better in terms of execution speed. The results show that the functional approach (Switch Fn style) outperforms the traditional switch statement (Vanilla Switch).

Pros and Cons

Traditional Switch Statement (Vanilla Switch)

Pros:

Easier to understand and maintain for developers familiar with the syntax.
Can be more efficient in certain cases, such as when using a large number of handlers.

Cons:

Tightly coupled with the specific handler names and values.
May require more memory allocation due to the use of a switch statement.

Functional Approach (Switch Fn style)

Pros:

More flexible and reusable, as it can be applied to various scenarios without modifying the underlying code.
Can lead to better maintainability and scalability in larger applications.

Cons:

Requires a deeper understanding of functional programming concepts and may be less intuitive for developers unfamiliar with this paradigm.
May introduce additional overhead due to the creation of new functions and closures.

Other Considerations

Both approaches have their trade-offs, and the choice between them depends on the specific use case, team preferences, and performance requirements. In general, the functional approach can provide better maintainability and scalability, but may require more expertise in functional programming concepts.

Library: isFunc and .isDefined

These functions are used to check if a value is a function or defined, respectively. They are likely utility functions used within the benchmark for testing purposes.

Special JS Feature/Syntax: switchEnum

This feature is used to define a set of handlers with values as keys and functions as values. It's an extension to the traditional switch statement that allows for more flexibility in handling different cases.

Note that switchEnum is not a standard JavaScript feature, but rather a custom implementation within this benchmark.

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares two approaches: the traditional `switch` statement and a functional programming style using a callback function.

**Traditional Switch Statement (Vanilla Switch)**

The traditional switch statement is compared to its functional equivalent. In this case, both test cases use the same code structure:

1. Define a set of handlers with values as keys and functions as values.
2. Use the `switch` statement to select the corresponding handler based on the input value.
3. Call the selected function with the input value as an argument.

In the vanilla switch test case, the `normal` function is called with different input values: `"today"`, `"yesterday"`, and `"tomorrow"`.

**Functional Approach (Switch Fn style)**

The functional approach uses a callback function to achieve the same result:

1. Define a set of handlers with values as keys and functions as values.
2. Use a closure to capture the handlers object and create a new function `funcccy` that takes an input value.
3. Within `funcccy`, call the `switchEnum` function with the input value and the handlers object.

In this test case, the `funcccy` function is called with different input values: `"today"`, `"yesterday"`, and `"tomorrow"`.

**Comparison**

The comparison between these two approaches aims to measure which one performs better in terms of execution speed. The results show that the functional approach (`Switch Fn style`) outperforms the traditional switch statement (`Vanilla Switch`).

**Pros and Cons**

**Traditional Switch Statement (Vanilla Switch)**

Pros:

* Easier to understand and maintain for developers familiar with the syntax.
* Can be more efficient in certain cases, such as when using a large number of handlers.

Cons:

* Tightly coupled with the specific handler names and values.
* May require more memory allocation due to the use of a `switch` statement.

**Functional Approach (Switch Fn style)**

Pros:

* More flexible and reusable, as it can be applied to various scenarios without modifying the underlying code.
* Can lead to better maintainability and scalability in larger applications.

Cons:

* Requires a deeper understanding of functional programming concepts and may be less intuitive for developers unfamiliar with this paradigm.
* May introduce additional overhead due to the creation of new functions and closures.

**Other Considerations**

**Library: `isFunc` and `.isDefined`**

These functions are used to check if a value is a function or defined, respectively. They are likely utility functions used within the benchmark for testing purposes.

**Special JS Feature/Syntax: `switchEnum`**

This feature is used to define a set of handlers with values as keys and functions as values. It's an extension to the traditional `switch` statement that allows for more flexibility in handling different cases.

Note that `switchEnum` is not a standard JavaScript feature, but rather a custom implementation within this benchmark.

Related benchmarks:

Switch vs Functional Approach (version: 0)

Comparing performance of: Vanilla Switch vs Switch Fn style

Created: one year ago by: Guest

Jump to the latest result

Vanilla Switch

Switch Fn style

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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