Benchmark: Javascript Array sorting performance with sort() and reduce() small array

HTML Preparation code:

<div id='min-data'></div>

AخA
 
<div id='min-data'></div>

Tests:

with reduce()

const div = document.getElementById('min-data');

const newArray = [];
for(let i = 0; i < 10; i++){
	const num = Math.floor(Math.random() * 10);
	newArray.push(num);
} 
newArray.reduce((a, b) => (a < b ? a : b), []);
div.innerHTML = newArray[0].toString();

​x
 
const div = document.getElementById('min-data');​const newArray = [];for(let i = 0; i < 10; i++){    const num = Math.floor(Math.random() * 10);    newArray.push(num);} newArray.reduce((a, b) => (a < b ? a : b), []);div.innerHTML = newArray[0].toString();

with sort()

const div = document.getElementById('min-data');

const newArray = [];
for(let i = 0; i < 10; i++){
	const num = Math.floor(Math.random() * 10);
	newArray.push(num);
} 
newArray.sort((a, b) => a - b);
div.innerHTML = newArray[0].toString();

 
const div = document.getElementById('min-data');​const newArray = [];for(let i = 0; i < 10; i++){    const num = Math.floor(Math.random() * 10);    newArray.push(num);} newArray.sort((a, b) => a - b);div.innerHTML = newArray[0].toString();

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
with reduce()
with sort()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Linux

View result in a separate tab

Test name	Executions per second
with reduce()	371129.1 Ops/sec
with sort()	390799.7 Ops/sec

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

Let's break down the provided benchmark and its test cases.

Benchmark Purpose:

The benchmark measures the performance of two different approaches to sort a small array in JavaScript: using the sort() method versus using the reduce() method with a custom comparison function.

Options Compared:

sort() method: This is a built-in JavaScript method that sorts an array in-place, returning the sorted array.
reduce() method with custom comparison: This method applies a reduction operation to each element in the array, using a callback function to compare elements and produce a single output value.

Pros and Cons of Each Approach:

sort() method:
- Pros:
  - Fast and efficient for small arrays.
  - Easy to use and understand.
- Cons:
  - Can be slower for very large arrays due to the in-place sorting algorithm used by default.
  - May not be suitable for arrays with non-numeric values, as it assumes numeric comparisons by default.
reduce() method with custom comparison:
- Pros:
  - Flexible and can handle arrays with non-numeric values or complex comparison logic.
  - Can produce a single output value after reduction, which might be desirable in some cases.
- Cons:
  - Typically slower than the sort() method due to its iterative nature.
  - Requires more code and setup for custom comparisons.

Library Used:

None. The benchmark uses only built-in JavaScript methods and variables.

Special JS Feature or Syntax:

The benchmark uses a few modern JavaScript features, such as:

Template literals: Used in the div.innerHTML = newArray[0].toString(); line to create a string from the array element.
Arrow functions: Used in the callback function of both the sort() and reduce() methods.

Benchmark Preparation Code:

The provided HTML code <div id='min-data'></div> is used to create an empty container for displaying the benchmark results.

Other Alternatives:

Other sorting algorithms: The benchmark could be modified to use other sorting algorithms, such as quicksort or mergesort.
Parallel execution: The benchmark could be executed in parallel across multiple CPU cores or devices to measure performance benefits of multi-threading.
Different input sizes: The benchmark could be modified to test the performance of the sorting methods with larger or smaller array sizes.

Note that these alternatives would require modifications to the benchmark code and are not currently part of the provided benchmark.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Purpose:**

The benchmark measures the performance of two different approaches to sort a small array in JavaScript: using the `sort()` method versus using the `reduce()` method with a custom comparison function.

**Options Compared:**

1. **`sort()` method**: This is a built-in JavaScript method that sorts an array in-place, returning the sorted array.
2. **`reduce()` method with custom comparison**: This method applies a reduction operation to each element in the array, using a callback function to compare elements and produce a single output value.

**Pros and Cons of Each Approach:**

1. **`sort()` method:**
	* Pros:
		+ Fast and efficient for small arrays.
		+ Easy to use and understand.
	* Cons:
		+ Can be slower for very large arrays due to the in-place sorting algorithm used by default.
		+ May not be suitable for arrays with non-numeric values, as it assumes numeric comparisons by default.
2. **`reduce()` method with custom comparison:**
	* Pros:
		+ Flexible and can handle arrays with non-numeric values or complex comparison logic.
		+ Can produce a single output value after reduction, which might be desirable in some cases.
	* Cons:
		+ Typically slower than the `sort()` method due to its iterative nature.
		+ Requires more code and setup for custom comparisons.

**Library Used:**

None. The benchmark uses only built-in JavaScript methods and variables.

**Special JS Feature or Syntax:**

The benchmark uses a few modern JavaScript features, such as:

1. **Template literals**: Used in the `div.innerHTML = newArray[0].toString();` line to create a string from the array element.
2. **Arrow functions**: Used in the callback function of both the `sort()` and `reduce()` methods.

**Benchmark Preparation Code:**

The provided HTML code `<div id='min-data'></div>` is used to create an empty container for displaying the benchmark results.

**Other Alternatives:**

1. **Other sorting algorithms**: The benchmark could be modified to use other sorting algorithms, such as quicksort or mergesort.
2. **Parallel execution**: The benchmark could be executed in parallel across multiple CPU cores or devices to measure performance benefits of multi-threading.
3. **Different input sizes**: The benchmark could be modified to test the performance of the sorting methods with larger or smaller array sizes.

Note that these alternatives would require modifications to the benchmark code and are not currently part of the provided benchmark.

Related benchmarks:

Javascript Array sorting performance with sort() and reduce() small array (version: 0)

Javascript Array sorting performance with sort() and reduce()

Comparing performance of: with reduce() vs with sort()

Created: 9 months ago by: Registered User

Jump to the latest result