Benchmark: Sum speed test - MeasureThat.net

Script Preparation code:

var niz = new Array(30000)

Tests:

For loop
var sum = 0; for(var i=0; i<niz.length;i++){ sum+= niz[i] }
Reduce
var sum = niz.reduce((a,b)=>{return a+b}, 0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For loop
Reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 135 on Linux

View result in a separate tab

Test name	Executions per second
For loop	27760.5 Ops/sec
Reduce	26596.6 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!

**Benchmark Overview**

The provided benchmark compares two approaches to calculate the sum of an array: using a `FOR` loop and using the `REDUCE` method. The benchmark aims to measure which approach is faster on modern hardware.

**Options Compared**

1. **FOR Loop**: This approach uses a traditional `for` loop to iterate over the array elements, adding each element to a running sum.
2. **REDUCE**: This approach uses the `reduce()` method, which applies a provided function to each element in an array, reducing it to a single output value.

**Pros and Cons of Each Approach**

1. **FOR Loop**
	* Pros:
		+ More readable code for complex calculations
		+ Can be used with more control over iteration (e.g., incrementing a variable)
	* Cons:
		+ More verbose code, which can lead to slower execution due to parsing overhead
		+ Limited support for parallel processing or concurrent execution
2. **REDUCE**
	* Pros:
		+ Concise and expressive code that leverages built-in functionality
		+ Can take advantage of parallel processing and concurrent execution
	* Cons:
		+ Less intuitive for complex calculations or control over iteration
		+ May require additional setup or configuration

**Library: Array.prototype.reduce()**

The `reduce()` method is a built-in JavaScript function that applies a provided function to each element in an array, reducing it to a single output value. This method is implemented in the browser's V8 engine and is optimized for performance.

**Special JS Feature/Syntax: None mentioned**

No special JavaScript features or syntax are used in this benchmark.

**Other Alternatives**

If you'd like to explore alternative approaches to calculate the sum of an array, consider the following:

1. **Array.prototype.forEach()**: While not as concise as `reduce()`, `forEach()` can be used with a callback function to iterate over the array elements.
2. **ES6 Iterators**: You could implement your own iterator using ES6's `Symbol.iterator` and `next()` methods, which would provide more control over iteration but might lead to slower performance due to the overhead of manual iteration management.

Keep in mind that these alternatives may not be as efficient or readable as the `FOR` loop or `REDUCE` method.

**Benchmark Preparation Code**

The provided script preparation code creates an array `niz` with 30,000 elements and declares a variable `sum`. The `FOR` loop and `REDUCE` function are then defined inside this scope, allowing the benchmark to focus on the performance comparison between these two approaches.

Related benchmarks:

Sum speed test (version: 0)

Diffrence between FOR loop and REDUCE

Comparing performance of: For loop vs Reduce

Created: 5 years ago by: Guest

Jump to the latest result

For loop

Reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):