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

Script Preparation code:

this.numberA = Math.random() * 1000;
this.numberB = Math.random() * 1000;

Tests:

Math.min
return Math.min(this.numberA, this.numberB);
if
if (this.numberA < this.numberB) return this.numberA; else return this.numberB;
ternary
return (this.numberA < this.numberB) ? this.numberA : this.numberB

Historical Performance Data aggregated from 140 community runs

Desktop Results:

Chrome 94 runs

35.2M/s

ternary

34.9M/s

Math.min

15.5M/s

Fastest: if (2.3x faster)

View exact numbers

✓ if: 35,192,912 ops/sec
• ternary: 34,885,328 ops/sec
• Math.min: 15,531,130 ops/sec

Firefox 31 runs

ternary

607.3M/s

534.4M/s

Math.min

41.0M/s

Fastest: ternary (14.8x faster)

View exact numbers

✓ ternary: 607,271,296 ops/sec
• if: 534,361,760 ops/sec
• Math.min: 40,991,072 ops/sec

Safari 5 runs

311.1M/s

ternary

301.6M/s

Math.min

11.8M/s

Fastest: if (26.4x faster)

View exact numbers

✓ if: 311,096,032 ops/sec
• ternary: 301,649,440 ops/sec
• Math.min: 11,783,476 ops/sec

Mobile Results:

Chrome 10 runs

ternary

16.3M/s

15.9M/s

Math.min

9.3M/s

Fastest: ternary (1.7x faster)

View exact numbers

✓ ternary: 16,257,832 ops/sec
• if: 15,901,036 ops/sec
• Math.min: 9,300,313 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.min
if
ternary

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Windows

View result in a separate tab

ternary

741.1M/s

270.8M/s

Math.min

62.2M/s

View exact numbers

Test name	Executions per second
✓ ternary	741,108,416 Ops/sec
if	270,818,560 Ops/sec
Math.min	62,191,564 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!

The provided JSON represents a benchmark test case on MeasureThat.net, which compares the performance of three different approaches to find the smaller of two numbers: `Math.min()`, `if/else` statements, and the ternary operator.

**Options compared:**

1. **Math.min()**: This is a built-in JavaScript function that returns the smallest of two or more values.
2. **if/else statements**: This approach involves using an if-else statement to compare the two numbers and return the smaller one.
3. **Ternary operator**: This is an alternative syntax for conditional expressions, which can be used to concisely evaluate a condition and return one of two values.

**Pros and cons of each approach:**

1. **Math.min()**:
	* Pros: Fast, efficient, and widely supported.
	* Cons: May not be suitable for all use cases (e.g., when you need more control over the comparison process).
2. **if/else statements**:
	* Pros: Allows for custom logic and flexibility in the comparison process.
	* Cons: Can be slower due to the overhead of branching instructions, especially in interpreted JavaScript environments like Chrome's V8 engine.
3. **Ternary operator**:
	* Pros: Compact syntax and often faster than if/else statements, as it avoids branching.
	* Cons: May not be immediately clear to readers, and its syntax can be specific to certain browsers or JavaScript engines.

**Library usage:** None of the provided benchmark definitions explicitly use a library. However, MeasureThat.net itself relies on various libraries under the hood, such as WebKit for rendering and V8 for JavaScript execution.

**Special JS feature/syntax:** The ternary operator is an example of a shorthand syntax in JavaScript, which allows you to write a single expression that can be either true or false. This syntax is supported by most modern browsers, including Chrome.

**Other alternatives:**

If you want to explore other options for finding the smaller of two numbers, consider:

1. `Math.max()` with `-a` and `-b` manipulation
2. Using bitwise operations (e.g., `a < b ? -a : -b`)
3. Implementing a custom comparison function using closures or arrow functions

Keep in mind that these alternatives might have different performance characteristics or use cases, so it's essential to benchmark them against the original three approaches to see which one works best for your specific scenario.

Now, if you'll excuse me, I need to go grab some virtual coffee and breathe...

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

Quickest operation to return smaller of 2 numbers

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

Created: 6 years ago by: Guest

Go to the latest result

Math.min

if

ternary

Historical Performance Data aggregated from 140 community runs

Desktop Results:

Chrome 94 runs

Firefox 31 runs

Safari 5 runs

Mobile Results:

Chrome 10 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.min vs if/else vs ternary operator (version: 0)

Quickest operation to return smaller of 2 numbers

Comparing performance of: Math.min vs if vs ternary

Created: 6 years ago by: Guest

Go to the latest result

Math.min

if

ternary

Historical Performance Data aggregated from 140 community runs

Desktop Results:

Chrome 94 runs

Firefox 31 runs

Safari 5 runs

Mobile Results:

Chrome 10 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.min vs if vs ternary`