Benchmark: Math.min vs if - getting min value from array

Script Preparation code:

arr = Array.from({ length: 10000 }, () => Math.random())

AخA
 
arr = Array.from({ length: 10000 }, () => Math.random())

Tests:

if

let v = 2;
for (const x of arr) {
 	if (x < v) v = x;
}
return v;

 
let v = 2;for (const x of arr) {    if (x < v) v = x;}return v;

Math.min

let v = 2;
for (const x of arr) {
 	v = Math.min(v, x);
}
return v;

 
let v = 2;for (const x of arr) {    v = Math.min(v, x);}return v;

Cached min

const min = Math.min;
let v = 2;
for (const x of arr) {
 	v = min(v, x);
}
return v;

 
const min = Math.min;let v = 2;for (const x of arr) {    v = min(v, x);}return v;

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
if
Math.min
Cached min

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.1.1

View result in a separate tab

Test name	Executions per second
if	46626.6 Ops/sec
Math.min	1043.7 Ops/sec
Cached min	21867.5 Ops/sec

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

Let's break down what's being tested in this benchmark.

Benchmark Definition

The test is comparing three approaches to find the minimum value in an array:

If statement: Using an if statement to iteratively update the minimum value.
Math.min function: Using the built-in Math.min function to find the minimum value.
Cached min: Creating a variable min and assigning it the Math.min function, then using this cached function to find the minimum value.

Options Compared

The three options are compared in terms of execution speed.

Pros and Cons

If statement:
- Pros: Easy to understand and implement, doesn't require a separate variable.
- Cons: Can be slow due to the iterative update process.
Math.min function:
- Pros: Fast and efficient, as it's implemented in native code.
- Cons: Requires importing the Math module or using the global Math object.
Cached min:
- Pros: Faster than the if statement approach, as it reuses the same function call.
- Cons: Requires creating a separate variable to cache the function.

Library

The test doesn't explicitly use any external libraries, but it does rely on the built-in Math module in JavaScript. The Math.min function is implemented in native code, which makes it fast and efficient.

Special JS Features or Syntax

There are no special JavaScript features or syntax used in this benchmark that would require explanation.

Other Alternatives

If you were to optimize the if statement approach further, you could consider using a more efficient algorithm like Boyer-Moore's algorithm for finding minimum values. However, this would add complexity and might not be necessary unless performance is critical.

The Math.min function can't be optimized further without changing its implementation in native code. The Cached min approach remains as the best alternative to the if statement approach in terms of execution speed.

Overall, this benchmark provides a simple yet informative comparison between three common approaches to finding minimum values in JavaScript arrays.

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Definition**

The test is comparing three approaches to find the minimum value in an array:

1. **If statement**: Using an if statement to iteratively update the minimum value.
2. **Math.min function**: Using the built-in Math.min function to find the minimum value.
3. **Cached min**: Creating a variable `min` and assigning it the Math.min function, then using this cached function to find the minimum value.

**Options Compared**

The three options are compared in terms of execution speed.

**Pros and Cons**

1. **If statement**:
	* Pros: Easy to understand and implement, doesn't require a separate variable.
	* Cons: Can be slow due to the iterative update process.
2. **Math.min function**:
	* Pros: Fast and efficient, as it's implemented in native code.
	* Cons: Requires importing the Math module or using the global `Math` object.
3. **Cached min**:
	* Pros: Faster than the if statement approach, as it reuses the same function call.
	* Cons: Requires creating a separate variable to cache the function.

**Library**

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark that would require explanation.

**Other Alternatives**

The `Math.min` function can't be optimized further without changing its implementation in native code. The `Cached min` approach remains as the best alternative to the if statement approach in terms of execution speed.

Overall, this benchmark provides a simple yet informative comparison between three common approaches to finding minimum values in JavaScript arrays.

Related benchmarks:

Math.min vs if - getting min value from array (version: 0)

Comparing performance of: if vs Math.min vs Cached min

Created: one year ago by: Guest

Jump to the latest result

if