Benchmark: switch function vs switch inline vs object vs Map

Script Preparation code:

const getSwitch = function (input) {
	switch(input) {
      	case 0:
        	return 'zero';
    	case 1:
      		return 'one';
    	case 2:
      		return 'two';
    	case 3:
      		return 'three';
    	case 4:
      		return 'four';
     	case 5:
      		return 'five';
    	case 6:
      		return 'six';
    	case 7:
      		return 'seven';
    	case 8:
      		return 'eight';
      	case 9:
      		return 'nine';
    	case 10:
      		return 'ten';
  	}
}

const LUT = {
	0: 'zero',
  	1: 'one',
  	2: 'two',
  	3: 'three',
  	4: 'four',
  	5: 'five',
  	6: 'six',
  	7: 'seven',
  	8: 'eight',
  	9: 'nine',
  	10: 'ten'
}

const map = new Map([
  [0, 'zero'],
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
  [4, 'four'],
  [5, 'five'],
  [6, 'six'],
  [7, 'seven'],
  [8, 'eight'],
  [9, 'nine'],
  [10, 'ten']
]);

Tests:

switch function
const result = getSwitch(Math.floor(Math.random() * 10));
switch inline
let result; switch(Math.floor(Math.random() * 10)) { case 0: result = 'zero'; break; case 1: result = 'one'; break; case 2: result = 'two'; break; case 3: result = 'three'; break; case 4: result = 'four'; break; case 5: result = 'five'; break; case 6: result = 'six'; break; case 7: result = 'seven'; break; case 8: result = 'eight'; break; case 9: result = 'nine'; break; case 10: result = 'ten'; break; }
object
const result = LUT[Math.floor(Math.random() * 10)];
Map
const result = map.get(Math.floor(Math.random() * 10));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
switch function
switch inline
object
Map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Linux

View result in a separate tab

Test name	Executions per second
switch function	20525988.0 Ops/sec
switch inline	32947854.0 Ops/sec
object	164263936.0 Ops/sec
Map	696350016.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined by MeasureThat.net compares the performance of four different approaches to returning a string representation of numbers from 0 to 10 using JavaScript. The options being tested are:
1. **Switch Function**: A traditional function using a `switch` statement.
2. **Switch Inline**: An inline `switch` statement without a surrounding function.
3. **Object Lookup**: Using a standard JavaScript object as a lookup table (LUT).
4. **Map Lookup**: Utilizing the ES6 `Map` object for the same lookup purpose.

### Comparison of Approaches

#### 1. Switch Function
- **Implementation**: The function takes an input value and uses the `switch` statement to return the appropriate string.
- **Pros**: 
  - Clear and intuitive logic, especially for those familiar with switch-case syntax.
  - More readable for a small number of cases.
- **Cons**: 
  - Performance can be slower for many cases compared to lookups, as it evaluates each case sequentially.
  - Overhead of function calls if invoked multiple times.

#### 2. Switch Inline
- **Implementation**: Like the previous option, but the switch statement is placed directly in the benchmark code block.
- **Pros**: 
  - Avoids function calls, slightly improving performance in scenarios where function call overhead matters.
  - Same clarity as the switch function.
- **Cons**: 
  - Still suffers from performance issues with larger datasets.
  - Can become unwieldy with many cases because all logic is in one block.

#### 3. Object Lookup
- **Implementation**: Uses a standard JavaScript object (LUT) to directly access the string representation based on the input.
- **Pros**: 
  - Extremely fast for lookup operations since accessing properties in an object is efficient.
  - Simplifies the code significantly; easy to read and maintain.
- **Cons**: 
  - Limited scope for complex logic or handling tricky edge cases.
  - Some may argue it’s less explicit compared to switch statements for complex mappings.

#### 4. Map Lookup
- **Implementation**: This approach uses `new Map()` to create a map of number-string pairs and retrieves the string using the `.get()` method.
- **Pros**: 
  - Similar speed benefits to the object lookup due to efficient key access.
  - Allows for more flexibility in terms of keys (can use objects as keys).
  - Preserves insertion order, which could be beneficial in different contexts.
- **Cons**: 
  - Slightly more verbose than a plain object due to the necessity of using constructor syntax.
  - May have a larger memory footprint in certain scenarios compared to a plain object.

### Benchmark Results
The benchmark results showcase the performance of each approach measured in **executions per second**:
- **Map**: 696,350,016 executions per second, highlighting its efficiency.
- **Object**: 164,263,936 executions per second, indicating a significant drop yet still quite efficient.
- **Switch Inline**: 32,947,854 executions per second, showing that while it’s faster than the function, it doesn’t match the lookup methods.
- **Switch Function**: 20,525,988 executions per second, demonstrating the least performance among these options.

### Considerations
- **Use Case**: Depending on the application's needs, if you prioritize readability and maintainability for a limited number of cases, switch statements may still be favorable. Conversely, if performance is critical (especially for larger sets), either the object or Map approaches would be preferable.
- **Special Cases**: The switch statement is good for conditions beyond simple value matching (e.g., ranges) but gets complicated with multiple conditions. Objects and Maps are purely for direct value lookups.
- **Alternatives**: Other alternatives can include using conditional (if-else) structures, which can be more readable for a low number of cases but generally not as performant as the options tested here for straightforward mappings.

Overall, the benchmark provides valuable insights into the performance differences among these strategies for mapping numeric values to strings in JavaScript, enabling developers to make informed choices based on context and requirements.

Related benchmarks:

switch function vs switch inline vs object vs Map (version: 1)

Comparing performance of: switch function vs switch inline vs object vs Map

Created: 24 days ago by: Guest

Jump to the latest result

switch function

switch inline

object

Map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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