Benchmark: Math.max/min vs if vs ternary operator

Script Preparation code:

this.number = Math.random() * 1000;

Tests:

Math.max/min
return Math.max(250, Math.min(750, this.number));
if
var number = this.number; if(number < 250) return 250; if(number > 750) return 750; return number;
ternary
var number = this.number; return number < 250 ? 250 : (number > 750 ? 750 : number);

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 56 runs

56.2M/s

ternary

55.5M/s

Math.max/min

29.2M/s

Fastest: if (1.9x faster)

View exact numbers

✓ if: 56,248,016 ops/sec
• ternary: 55,467,204 ops/sec
• Math.max/min: 29,220,108 ops/sec

Firefox 18 runs

911.8M/s

ternary

901.3M/s

Math.max/min

56.1M/s

Fastest: if (16.3x faster)

View exact numbers

✓ if: 911,841,856 ops/sec
• ternary: 901,265,024 ops/sec
• Math.max/min: 56,065,112 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.max/min
if
ternary

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 150 on Windows

View result in a separate tab

Math.max/min

178.5M/s

ternary

175.9M/s

174.4M/s

View exact numbers

Test name	Executions per second
✓ Math.max/min	178,469,408 Ops/sec
ternary	175,878,240 Ops/sec
if	174,379,344 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided JSON represents a benchmark that compares three different approaches to find the maximum or minimum value between two numbers: `Math.max`, `if` statement, and ternary operator (`?:`). We'll break down each option, its pros and cons, and any relevant considerations.

**1. Math.max/min**

This approach uses the built-in `Math.max` or `Math.min` functions to find the maximum or minimum value between two numbers. The JavaScript engine can optimize these functions internally, making them a good choice for benchmarks that involve mathematical operations.

Pros:

* Fast execution speed due to native implementation
* Low overhead compared to other approaches

Cons:

* Limited control over the calculation process
* May not be suitable for custom or complex calculations

**2. if statement**

This approach uses an `if` statement to check the conditions and return the corresponding value. This method allows for more control over the calculation process but can be slower than the `Math.max/min` approach due to the overhead of the conditional checks.

Pros:

* More control over the calculation process
* Suitable for custom or complex calculations

Cons:

* Slower execution speed compared to `Math.max/min`
* More overhead due to conditional checks

**3. ternary operator (?:)**

The ternary operator is a shorthand way to write an `if` statement in a single expression. This approach combines the benefits of both the `if` statement and `Math.max/min`.

Pros:

* Balanced execution speed, neither too fast nor too slow
* Compact code, making it easier to read and maintain

Cons:

* May be slightly slower than `Math.max/min`
* Less control over the calculation process compared to `if` statements

**Library usage:**

In this benchmark, there is no explicit library usage. However, it's worth noting that some libraries like `lodash` or `ramda` can provide optimized functions for mathematical operations, which might affect the benchmark results.

**Special JS features or syntax:**

None of the provided benchmark definitions use any special JavaScript features or syntax beyond what is standard in modern JavaScript implementations (ECMAScript 2015+).

**Other alternatives:**

If you wanted to test alternative approaches, some possible options could be:

* Using bitwise operations (`Math.max` with bitwise shift or comparison)
* Implementing a custom `max`/`min` function using loops
* Using a different programming paradigm, such as functional programming

Keep in mind that these alternatives would likely have varying levels of performance and readability compared to the original benchmark.

In summary, the `Math.max/min` approach is generally the fastest due to its native implementation, while the `if` statement provides more control but at the cost of slightly slower execution speed. The ternary operator offers a balanced solution with compact code.

Math.max/min vs if vs ternary operator (version: 0)

Comparing performance of: `Math.max/min vs if vs ternary`

Created: 8 years ago by: Registered User

Go to the latest result

Math.max/min

if

ternary

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 56 runs

Firefox 18 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Math.max/min vs if vs ternary operator (version: 0)

Comparing performance of: Math.max/min vs if vs ternary

Created: 8 years ago by: Registered User

Go to the latest result

Math.max/min

if

ternary

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 56 runs

Firefox 18 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

Comparing performance of: `Math.max/min vs if vs ternary`