Benchmark: Perfomance: Switch (with functions) vs Polymorphism (with methods)

Script Preparation code:

var class1 = {
    GetImportantValue: () => 1
};
var class2 = {
    GetImportantValue: () => 2
};
var class3 = {
    GetImportantValue: () => 3
};
var class4 = {
    GetImportantValue: () => 4
};
var class5 = {
    GetImportantValue: () => 5
};

function GetImportantValue1() {
    return 1;
}

function GetImportantValue2() {
    return 2;
}

function GetImportantValue3() {
    return 3;
}

function GetImportantValue4() {
    return 4;
}

function GetImportantValue5() {
    return 5;
}

getImportantValueSwitch = (myClassEnum) => {
    switch (myClassEnum.type) {
        case 'MyClass1':
            return GetImportantValue1();
        case 'MyClass2':
            return GetImportantValue2();
        case 'MyClass3':
            return GetImportantValue3();
        case 'MyClass4':
            return GetImportantValue4();
        case 'MyClass5':
            return GetImportantValue5();
    }
}

getImportantValuePolymorphism = (myClass) => myClass.GetImportantValue();

Tests:

Polymorphism
getImportantValuePolymorphism(class1); getImportantValuePolymorphism(class2); getImportantValuePolymorphism(class3); getImportantValuePolymorphism(class4); getImportantValuePolymorphism(class5);
Switch
getImportantValueSwitch({type: 'MyClass1'}); getImportantValueSwitch({type: 'MyClass2'}); getImportantValueSwitch({type: 'MyClass3'}); getImportantValueSwitch({type: 'MyClass4'}); getImportantValueSwitch({type: 'MyClass5'});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Polymorphism
Switch

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Polymorphism	4459813.0 Ops/sec
Switch	2767863.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):

LLMs can make mistakes. Check important info.

In this benchmark, two approaches for determining values associated with classes are compared: *polymorphism* using methods and a *switch* statement. The purpose is to evaluate their performance in terms of execution speed.

### Approaches Being Compared

1. **Polymorphism (with methods)**
   - *Description*: In this approach, each class has a method `GetImportantValue()` that returns its respective value. The polymorphic behavior allows the code to call the method directly without needing to know the type of class at the time of calling.
   - *How it works*: The benchmark makes calls to `getImportantValuePolymorphism` for each class (class1 to class5). The function simply invokes the method `GetImportantValue()` of each class.

2. **Switch Statement**
   - *Description*: This approach uses a `switch` statement to determine which function to call based on an enumeration type passed to it. Each class is represented by a type string, and a corresponding function is called in the `switch` based on that string.
   - *How it works*: The benchmark executes the `getImportantValueSwitch` function, passing an object containing a type property (like 'MyClass1', 'MyClass2', etc.) which directs the program flow to the correct case in the switch block.

### Results
- **Polymorphism** achieved **4,459,813 executions per second.**
- **Switch** achieved **2,767,863.5 executions per second.**

### Pros and Cons

**Polymorphism Pros:**
- **Readability and Maintainability**: The code is easier to read and maintain because it leverages object-oriented programming principles.
- **Extensibility**: Adding more classes simply requires creating new classes with the method without changing existing code.

**Polymorphism Cons:**
- **Overhead**: There may be a slight performance overhead due to method lookups, depending on the JavaScript engine's optimizations.

**Switch Pros:**
- **Simplicity for Predictable Cases**: The use of switch is straightforward in scenarios with a limited, well-defined set of types.
- **Potentially Faster**: For small sets of possible cases, it can be faster since there’s no method resolution overhead.

**Switch Cons:**
- **Harder to Maintain**: Adding a new type necessitates modifying the switch statement, which can introduce bugs and complicate future maintenance.
- **Longer Code**: It can lead to verbose code compared to a polymorphic approach, especially with larger numbers of classes.

### Other Considerations
- **Performance Variability**: Performance can vary based on the JavaScript engine (like V8 in Chrome or SpiderMonkey in Firefox) and how it optimizes code execution, making benchmarking context-specific.
- **Use Case**: Choice of approach should depend on use case: polymorphism serves better in systems designed for extensibility, while switch may suffice in simpler cases.

### Libraries and Features
In this benchmark, no special JavaScript libraries or features are utilized beyond basic functions and structures. The benchmark mainly uses core JavaScript syntax and capabilities.

### Alternatives
- **Strategy Pattern**: Use a more advanced design pattern like the Strategy pattern, which allows for switching between algorithms or behaviors at runtime by encapsulating the variations in separate classes.
- **Lookup Tables**: Using an object literal as a registry for functions could provide a balance between speed and maintainability, reducing the need for conditionals altogether.

In conclusion, this JavaScript benchmark serves to evaluate two common methods for value retrieval through classes, showcasing the trade-offs between simplicity and optimization in code design. Each method has its unique strengths and weaknesses that can significantly affect performance depending on use cases.

Related benchmarks:

Perfomance: Switch (with functions) vs Polymorphism (with methods) (version: 1)

https://stackoverflow.com/questions/50401725/perfomance-switch-vs-polymorphism

Comparing performance of: Polymorphism vs Switch

Created: 6 days ago by: Guest

Jump to the latest result

Polymorphism

Switch

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):