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

Script Preparation code:

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

function max(v1, v2) {
  if (v1 > v2) return v1;
  return v2;
}

function min(v1, v2) {
  if (v1 < v2) return v1;
  return v2;
}

​x
 
this.number = Math.random() * 1000;​function max(v1, v2) {  if (v1 > v2) return v1;  return v2;}​function min(v1, v2) {  if (v1 < v2) return v1;  return v2;}

Tests:

Math.max/min
return Math.max(250, Math.min(750, this.number));
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;

 
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);

 
var number = this.number;return number < 250 ? 250 : (number > 750 ? 750 : number);

custom function
return max(250, min(750, this.number));
return max(250, min(750, this.number));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Math.max/min
if
ternary
custom function

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/110.0

Browser/OS: Firefox 110 on Linux

View result in a separate tab

Test name	Executions per second
Math.max/min	17512906.0 Ops/sec
if	673137664.0 Ops/sec
ternary	672500736.0 Ops/sec
custom function	637094016.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's dive into the explanation.

Benchmark Definition JSON

The benchmark definition represents a set of test cases for comparing different approaches to achieve a specific result. In this case, we have four test cases:

Math.max/min: Uses the built-in Math.max and Math.min functions to compare two values.
if: Uses an if-else statement with conditional checks to determine the maximum value.
ternary: Uses a ternary operator to achieve the same result as the previous test case.
custom function: Defines a custom function named max and min to compare two values.

Options Compared

We're comparing four different approaches:

Built-in functions (Math.max/min)
Conditional checks with if-else statements (if)
Ternary operator (ternary)
Custom functions (custom function)

Pros and Cons of Each Approach

Here's a brief overview of the pros and cons of each approach:

Built-in functions (Math.max/min):
- Pros: Efficient, widely supported, and well-optimized.
- Cons: May not be as intuitive or easy to understand for some developers.
Conditional checks with if-else statements (if):
- Pros: Easy to understand and implement, but may lead to performance issues due to branching.
- Cons: Can be slower than built-in functions and custom implementations.
Ternary operator (ternary):
- Pros: Concise and easy to read, similar to if-else statements.
- Cons: May not be as efficient or widely supported as other approaches.
Custom functions (custom function):
- Pros: Can be optimized for specific use cases and may lead to better performance.
- Cons: Requires defining a custom function, which can add overhead.

Library Usage

None of the test cases explicitly uses any external libraries. However, it's worth noting that the Math library is used implicitly by relying on its built-in functions.

Special JavaScript Feature or Syntax

No special features or syntax are used in this benchmark. The focus is solely on comparing different approaches to achieve a specific result.

Other Alternatives

Some alternative approaches could be considered, such as:

Using array methods (e.g., Math.max.apply, Array.prototype.max)
Implementing the comparison logic using bitwise operators
Utilizing SIMD instructions (if supported by the target browser)

However, these alternatives are not included in the benchmark definition, and their performance would likely vary depending on the specific implementation.

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Definition JSON**

The benchmark definition represents a set of test cases for comparing different approaches to achieve a specific result. In this case, we have four test cases:

1. `Math.max/min`: Uses the built-in `Math.max` and `Math.min` functions to compare two values.
2. `if`: Uses an if-else statement with conditional checks to determine the maximum value.
3. `ternary`: Uses a ternary operator to achieve the same result as the previous test case.
4. `custom function`: Defines a custom function named `max` and `min` to compare two values.

**Options Compared**

We're comparing four different approaches:

1. Built-in functions (`Math.max/min`)
2. Conditional checks with if-else statements (`if`)
3. Ternary operator (`ternary`)
4. Custom functions (`custom function`)

**Pros and Cons of Each Approach**

Here's a brief overview of the pros and cons of each approach:

* **Built-in functions (Math.max/min)**:
	+ Pros: Efficient, widely supported, and well-optimized.
	+ Cons: May not be as intuitive or easy to understand for some developers.
* **Conditional checks with if-else statements (if)**:
	+ Pros: Easy to understand and implement, but may lead to performance issues due to branching.
	+ Cons: Can be slower than built-in functions and custom implementations.
* **Ternary operator (ternary)**:
	+ Pros: Concise and easy to read, similar to if-else statements.
	+ Cons: May not be as efficient or widely supported as other approaches.
* **Custom functions (custom function)**:
	+ Pros: Can be optimized for specific use cases and may lead to better performance.
	+ Cons: Requires defining a custom function, which can add overhead.

**Library Usage**

None of the test cases explicitly uses any external libraries. However, it's worth noting that the `Math` library is used implicitly by relying on its built-in functions.

**Special JavaScript Feature or Syntax**

No special features or syntax are used in this benchmark. The focus is solely on comparing different approaches to achieve a specific result.

**Other Alternatives**

Some alternative approaches could be considered, such as:

* Using array methods (e.g., `Math.max.apply`, `Array.prototype.max`)
* Implementing the comparison logic using bitwise operators
* Utilizing SIMD instructions (if supported by the target browser)

However, these alternatives are not included in the benchmark definition, and their performance would likely vary depending on the specific implementation.

Related benchmarks:

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

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

Created: 6 years ago by: Guest

Jump to the latest result

Math.max/min

if