Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
math.min/max vs sort
(version: 0)
Comparing performance of:
Math.min vs Math.max vs sort (asc) vs sort (desc)
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var array = Array(100000).fill(0).map(v => parseInt(Math.random() * (1000000 - 0) + 0))
Tests:
Math.min
Math.min(...array)
Math.max
Math.max(...array)
sort (asc)
array.sort((a, b) => a - b)
sort (desc)
array.sort((a, b) => b - a)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
Math.min
Math.max
sort (asc)
sort (desc)
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36
Browser/OS:
Chrome 123 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=515133" width="100%" height="500px"></iframe>
Math.max
7K/s
Math.min
6K/s
sort (asc)
797/s
sort (desc)
795/s
View exact numbers
Test name
Executions per second
✓
Math.max
6,508 Ops/sec
Math.min
6,465 Ops/sec
sort (asc)
797 Ops/sec
sort (desc)
795 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and explain what's being tested. **Benchmark Overview** The benchmark compares the performance of three different approaches to find the minimum or maximum value in an array: 1. Using the `Math.min()` function 2. Using the `Math.max()` function 3. Sorting the array and then finding the first element (ascending) or last element (descending) **Options Compared** * `Math.min()` vs `Math.max()`: This comparison tests the performance of finding the smallest and largest values in an array using built-in JavaScript functions. + Pros: Easy to implement, fast, and widely supported. + Cons: May not be optimized for large arrays or specific use cases (e.g., finding the median). * Sorting vs native min/max functions: This comparison tests the performance of sorting the entire array before finding the minimum or maximum value compared to using built-in functions. + Pros: Can be useful in certain scenarios, like when you need to perform additional operations on the sorted data. + Cons: Sorts the entire array, which can be slower for large arrays and may not be necessary if you only need to find a single minimum or maximum value. **Library Used** There is no explicit library mentioned in the provided benchmark. However, it's likely that the `Array.prototype` methods (e.g., `fill()`, `map()`) are used as part of the benchmark. **Special JS Feature/Syntax** The benchmark uses the `Math.random()` function to generate random numbers for creating an array with random values. This is a standard JavaScript feature and not specific to any particular version or syntax. **Benchmark Preparation Code** The preparation code creates an array of 100,000 elements, each initialized with a random integer value between 0 and 1,000,000. **Other Considerations** * The benchmark uses Chrome 123 as the browser, but it's likely that other browsers would have similar performance characteristics. * The test is run on a desktop platform, which may not be representative of mobile or web-based scenarios where performance differences might occur. * The `ExecutionsPerSecond` value indicates how many times each operation is executed per second, providing an idea of the relative performance of each approach. **Alternatives** Some alternative approaches to finding the minimum or maximum value in an array include: * Using a custom implementation, such as a binary search algorithm, which can be more efficient for large arrays. * Using parallel processing or multi-threading to take advantage of multiple CPU cores. * Implementing a hybrid approach that combines the benefits of built-in functions with custom optimizations. Keep in mind that the performance differences between these approaches will depend on specific use cases and hardware configurations.
Related benchmarks
array vs Float64Array (small) 2
array vs Float64Array sort
Math.min vs Array.sort[0]
Array.sort vs Math.min 1
Comments
Confirm delete:
Do you really want to delete benchmark?