Benchmark: lookup table vs switch 2

Tests:

lookup
var LOOKUP = [ ()=>{return 'a';}, ()=>{return 'b';}, ()=>{return 'c';}, ()=>{return 'd';}, ()=>{return 'e';}, ()=>{return 'f';}, ()=>{return 'g';}, ()=>{return 'h';}, ()=>{return 'i';}, ()=>{return 'j';}, ()=>{return 'k';} ]; LOOKUP[Math.floor(Math.random() * 11)];
switch
let a = Math.floor(Math.random() * 11); switch (a) { case 0:return 'a'; case 1:return 'b'; case 2:return 'c'; case 3:return 'd'; case 4:return 'e'; case 5:return 'f'; case 6:return 'g'; case 7:return 'h'; case 8:return 'i'; case 9:return 'j'; case 10:return 'k'; }
switch 2
let a = Math.floor(Math.random() * 11); switch (a) { case 0:a='a';break; case 1:a= 'b';break; case 2:a= 'c';break; case 3:a= 'd';break; case 4:a= 'e';break; case 5:a= 'f';break; case 6:a= 'g';break; case 7:a= 'h';break; case 8:a= 'i';break; case 9:a= 'j';break; case 10:a= 'k';break; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lookup
switch
switch 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 OPR/87.0.0.0

Browser/OS: Opera 87 on Android

View result in a separate tab

Test name	Executions per second
lookup	2331590.5 Ops/sec
switch	10237866.0 Ops/sec
switch 2	10739024.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

In this benchmark, titled "lookup table vs switch 2," we compare the performance of two different methods for retrieving values based on integer input: using a lookup table (array of functions) versus a switch statement in JavaScript.

### Test Cases Overview

1. **Lookup Table Method (`lookup` Test Case)**
   ```javascript
   var LOOKUP = [
     () => { return 'a'; },
     () => { return 'b'; },
     () => { return 'c'; },
     () => { return 'd'; },
     () => { return 'e'; },
     () => { return 'f'; },
     () => { return 'g'; },
     () => { return 'h'; },
     () => { return 'i'; },
     () => { return 'j'; },
     () => { return 'k'; }
   ];
   LOOKUP[Math.floor(Math.random() * 11)];
   ```
   This test case creates an array of functions that each return a single character from 'a' to 'k'. The benchmark picks a random index between 0 and 10 and calls the corresponding function to get the value.

2. **Switch Statement Method (`switch` Test Case)**
   ```javascript
   let a = Math.floor(Math.random() * 11);
   switch (a) {
     case 0: return 'a';
     case 1: return 'b';
     case 2: return 'c';
     case 3: return 'd';
     case 4: return 'e';
     case 5: return 'f';
     case 6: return 'g';
     case 7: return 'h';
     case 8: return 'i';
     case 9: return 'j';
     case 10: return 'k';
   }
   ```
   In this approach, a random number is generated, and the switch statement handles value selection by matching cases with a simple return of corresponding characters.

3. **Alternate Switch Syntax (`switch 2` Test Case)**
   ```javascript
   let a = Math.floor(Math.random() * 11);
   switch (a) {
     case 0: a='a'; break;
     case 1: a= 'b'; break;
     case 2: a= 'c'; break;
     case 3: a= 'd'; break;
     case 4: a= 'e'; break;
     case 5: a= 'f'; break;
     case 6: a= 'g'; break;
     case 7: a= 'h'; break;
     case 8: a= 'i'; break;
     case 9: a= 'j'; break;
     case 10: a= 'k'; break;
   }
   ```
   This variation of the switch statement also selects a character based on the random number, but instead of returning values directly, it modifies the variable `a` to hold the character.

### Performance Results

The benchmark results show the number of executions per second for each method:
- **`switch 2`**: 48,089,656 executions/second
- **`switch`**: 28,759,368 executions/second
- **`lookup`**: 17,060,494 executions/second

### Pros and Cons

1. **Lookup Table (Function Array)**
   - **Pros**:
     - Simple syntax for adding/removing elements.
     - Can be beneficial for large data sets (conciseness).
   - **Cons**:
     - Slightly slower in performance, as function calls require execution overhead.

2. **Switch Statement**
   - **Pros**:
     - Fast execution for a moderate number of cases due to direct branching.
     - Readability can be higher with explicit returns (in `switch` method).
   - **Cons**:
     - As case numbers rise, maintainability can reduce.
     - More boilerplate code is required compared to lookup tables.

3. **Switch with Assignment (`switch 2`)**
   - **Pros**:
     - Similar performance as the basic switch.
     - Allows assignment which could be useful in contexts beyond direct value retrieval.
   - **Cons**:
     - Slightly less clear due to side effects on the variable `a`.

### Other Considerations and Alternatives
- The performance difference between these methods could vary based on the JavaScript engine's optimization techniques (e.g., diff speeds in V8 vs. SpiderMonkey).
- If the range of cases were to become large, alternatives might include using hash maps for lookups or considering functional programming approaches.
- For dynamic cases or very frequent access, a precomputed array or direct object access might provide better performance compared to both the switch and lookup methods.
- Developers should choose between these alternatives based on their application's specific needs regarding readability, maintainability, and performance.

Overall, understanding the pros and cons of these different techniques and how they might perform under various conditions is crucial for optimizing code in JavaScript-based applications.

Related benchmarks:

lookup table vs switch 2 (version: 2)

Comparing performance of: lookup vs switch vs switch 2

Created: 3 months ago by: Registered User

Jump to the latest result

lookup

switch

switch 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):