Toggle navigation
MeasureThat.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Jump table vs switch case
(version: 0)
Comparing performance of:
switch case vs jump table
Created:
2 years ago
by:
Registered User
Jump to the latest result
Tests:
switch case
function thing(j) { switch(j) { case 0: return "rah"; case 1: return "lah"; case 2: return "sah"; case 3: return "blah"; } } for(let i = 0; i < 100000; i++) { for(let j = 0; thing(j) != "blah"; j++) { } }
jump table
function rah() { return "rah"; } function lah() { return "lah"; } function sah() { return "sah"; } function blah() { return "blah"; } let jumpTable = { [0]: rah, [1]: lah, [2]: sah, [3]: blah}; for(let i = 0; i < 100000; i++) { for(let j = 0; jumpTable[j]() != "blah"; j++) { } }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
switch case
jump table
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
28 days ago
)
User agent:
Mozilla/5.0 (X11; Linux x86_64; rv:147.0) Gecko/20100101 Firefox/147.0
Browser/OS:
Firefox 147 on Linux
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=627545" width="100%" height="500px"></iframe>
Test name
Executions per second
switch case
618.4 Ops/sec
jump table
455.8 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's dive into the world of JavaScript microbenchmarks! The provided JSON represents two benchmark definitions: 1. **Jump table vs switch case**: This benchmark compares the performance of using a `switch` statement versus an array-based "jump table" to implement a simple function that returns different strings based on input values (0, 1, 2, or 3). 2. **Test Case: switch case**: This is an individual test case for the first benchmark definition. **Options compared:** In the `switch` statement approach: * The `switch` statement itself * A loop that iterates 100,000 times and calls the function with a value from 0 to 3 In the jump table approach: * An object (`jumpTable`) that maps input values to functions (using array notation `[0]: rah, [1]: lah, ...`) * A loop that iterates 100,000 times and calls the corresponding function from the `jumpTable` **Pros and Cons:** **Switch statement:** Pros: * Readability and maintainability are generally better for complex logic * Compile-time checks can help catch errors Cons: * Can be slower due to the overhead of jumping between cases (e.g., in JavaScript engines) * Can lead to performance issues if the number of cases is very large **Jump table:** Pros: * Can be faster since it uses a direct array lookup instead of jumping between cases * Can reduce memory usage for large numbers of cases Cons: * Readability and maintainability might suffer, especially for complex logic * Requires careful management of case values to avoid collisions or index out-of-bounds errors **Other considerations:** * The number of iterations (100,000) is relatively small, so the differences in performance may not be significant. * Both approaches use a loop, which can dominate the execution time. * The `switch` statement approach might benefit from compiler optimizations specific to JavaScript engines. **Library or special JS feature:** Neither of these benchmarks uses any external libraries. However, if we were to analyze the code further, we'd notice that both examples use simple functions (e.g., `rah`, `lah`, etc.) that are defined inline. **Special JS features or syntax:** There's no explicit mention of special JavaScript features like async/await, generators, or decorators in these examples. If there were additional code not shown here, it would be worth investigating to determine if any such features are being utilized. **Alternatives:** Other alternatives for implementing jump tables or switch statements could include: * Using a lookup table (similar to the `jumpTable` approach) but implemented using a different data structure, like an object with function values * Employing techniques like caching or memoization to reduce the number of function calls * Considering alternative approaches like using bitwise operations or arithmetic to implement jump tables Keep in mind that the specific alternatives would depend on the requirements and constraints of your particular use case. Hope this explanation helps!
Related benchmarks:
Jump vs switch case v2
switch case vs jump table vs bounce pattern vs ternary
Jump vs switch case vs else if for non-integers
Jump table vs switch case
Comments
Confirm delete:
Do you really want to delete benchmark?