Benchmark: Math.abs versus two equality checks

Script Preparation code:

const thenumber = -90

Tests:

Math.abs
if (Math.abs(thenumber) === 90) { console.log(thenumber) }
Two equals, negative first
if (thenumber === -90 || thenumber === 90) { console.log(thenumber) }
Two equals, positive first
if (thenumber === 90 || thenumber === -90) { console.log(thenumber) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.abs
Two equals, negative first
Two equals, positive first

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Test name	Executions per second
Math.abs	368456.4 Ops/sec
Two equals, negative first	349874.8 Ops/sec
Two equals, positive first	334978.6 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

This benchmark compares different approaches to checking whether the variable `thenumber`, which is set to -90, matches the value of 90 or -90. The three test cases are:

1. **Using `Math.abs`**:
   - **Test Case**: `if (Math.abs(thenumber) === 90) { console.log(thenumber) }`
   - **Pros**: 
     - Simple and clear in intention; it effectively checks for the absolute value of the number.
     - Readable and highlights the importance of positive and negative checks in a single function call.
   - **Cons**:
     - Introduces a function call overhead (in this case, `Math.abs`) which may add slight latency compared to direct value checks.
   - **Performance Result**: This approach had the highest executions per second among the three methods.

2. **Using two equality checks (negative first)**:
   - **Test Case**: `if (thenumber === -90 || thenumber === 90) { console.log(thenumber) }`
   - **Pros**:
     - No function overhead, making it potentially faster than using `Math.abs` for simple comparisons.
     - Directly checks the known values, which may optimize performance in scenarios where the numbers are fixed or known.
   - **Cons**:
     - Less readable when both `-90` and `90` are hardcoded; it may be unclear to some developers why both checks are present without additional context.
   - **Performance Result**: This method was slightly less performant than `Math.abs`.

3. **Using two equality checks (positive first)**:
   - **Test Case**: `if (thenumber === 90 || thenumber === -90) { console.log(thenumber) }`
   - **Pros**:
     - Similar benefits as the previous equality check method but differs in the order of checks.
     - Simple and avoids the overhead of a function call.
   - **Cons**:
     - As with the previous case, it is similarly less readable due to hardcoding the values.
   - **Performance Result**: This approach was the least performant among the three tested cases, albeit not significantly behind the negative-first check.

### Summary of Options Compared
- **Math.abs vs. equality checks**: The benchmark evaluates the trade-off between readability and potential performance impacts of using a built-in function versus straightforward equality checks.

### Other Considerations
- In scenarios where performance is crucial (such as in tight loops or real-time applications), the difference in execution speed of the options may become more significant. Developers should consider the context in which these checks are performed.
- Additionally, when working with variable ranges that involve different data types or more complex calculations, the choice of method may impact both performance and code maintainability.

### Alternatives
- **Logical Operators**: Using logical operators in creative ways (like bitwise operations) could provide alternatives, though readability may suffer.
- **Dedicated Libraries**: If dealing with a broader mathematical context, libraries like `lodash` or `underscore` can provide utility functions for checks and may include optimizations for specific cases. However, for simple comparisons like this, a direct approach is usually more efficient.
- **Type checking utilities**: In larger applications, utilizing TypeScript or JSDoc for type safety can improve maintainability and prevent runtime errors instead of relying purely on runtime checks.

In conclusion, while performance metrics are critical, the balance between readability, maintainability, and the specific context of code deployment is essential for making informed decisions in real-world applications.

Related benchmarks:

Math.abs versus two equality checks (version: 2)

Comparing performance of: Math.abs vs Two equals, negative first vs Two equals, positive first

Created: one year ago by: Registered User

Jump to the latest result

Math.abs

Two equals, negative first

Two equals, positive first

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):