Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
no loop, switch case vs bounce pattern vs ternary
(version: 0)
Benchmark.js
Comparing performance of:
switch case vs bounce patttern vs ternary
Created:
3 years ago
by:
Guest
Go to the latest result
Tests:
switch case
function thing(e) { switch (e) { case 0: return "0"; case 1: return "1"; case 2: return "2"; case 3: return "3"; default: return ""; } } thing(0), thing(2), thing(6)
bounce patttern
function bounce(x) { if (x === 0) return "0"; if (x === 1) return "1"; if (x === 2) return "2"; if (x === 3) return "3"; return "" } bounce(0), bounce(2), bounce(6)
ternary
function bounce(x) { return 0 === x ? "0" : 1 === x ? "1" : 2 === x ? "2" : 3 === x ? "3" : ""; } bounce(0), bounce(2), bounce(6)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
switch case
bounce patttern
ternary
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Browser/OS:
Chrome 120 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=495601" width="100%" height="500px"></iframe>
ternary
1099.7M/s
bounce patttern
1096.3M/s
switch case
1088.3M/s
View exact numbers
Test name
Executions per second
✓
ternary
1,099,734,656 Ops/sec
bounce patttern
1,096,303,872 Ops/sec
switch case
1,088,331,136 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided JSON data and explain what's being tested. **Benchmark Definition** The benchmark is comparing three different approaches to achieve the same result: 1. **Switch Case**: This approach uses a `switch` statement to check the input value against multiple cases. If the value matches one of the cases, it returns a corresponding string. 2. **Bounce Pattern**: This approach uses an if-else chain to check the input value against multiple values. If the value is not found in the chain, it returns an empty string. 3. **Ternary Operator**: This approach uses ternary operators (`?:`) to check the input value and return a corresponding string. **Options Compared** The benchmark is comparing these three approaches to determine which one is the most efficient (i.e., executes fastest). The benchmark measures the number of executions per second for each approach, which indicates how many times the function can execute in one second. **Pros and Cons** Here's a brief summary of the pros and cons of each approach: 1. **Switch Case**: * Pros: Can be more readable and maintainable than other approaches. * Cons: May have slower execution times due to the overhead of the `switch` statement. 2. **Bounce Pattern**: * Pros: Simple and easy to understand, with minimal overhead. * Cons: Can become cumbersome if there are many cases or values. 3. **Ternary Operator**: * Pros: Concise and expressive, with minimal overhead. * Cons: May be less readable for complex expressions. **Library** There is no library explicitly mentioned in the provided JSON data. However, the benchmark uses a common JavaScript feature: `switch` statements and if-else chains. **Special JS Features/Syntax** The benchmark does not use any special or advanced JavaScript features beyond what's considered standard. **Alternatives** If you were to rewrite these benchmarks using different approaches, here are some alternatives: 1. **Regular Expressions**: Instead of using a `switch` statement or if-else chain, you could use regular expressions to match the input value. 2. **Array Searching**: You could use array methods like `indexOf()` or `findIndex()` to search for the input value in an array of values. 3. **Object Lookup**: If the input value corresponds to a key in an object, you could use object lookup to retrieve the corresponding string. These alternatives would likely have different performance characteristics and trade-offs compared to the original approaches used in the benchmark.
Related benchmarks
switch case vs jump table vs bounce pattern vs ternary
Jump vs switch case vs else if for non-integers
Comments
Confirm delete:
Do you really want to delete benchmark?