Benchmark: for/for each/forEach array sum

Script Preparation code:

var array = new Array(1000);
for (var i = 0; i < array.length; i++) {
  array[i] = i;
}

​x
 
var array = new Array(1000);for (var i = 0; i < array.length; i++) {  array[i] = i;}​

Tests:

for

let sum = 0;
for (var i = 0; i < array.length; i++) {
  sum += array[i];
}

 
let sum = 0;for (var i = 0; i < array.length; i++) {  sum += array[i];}

for each

let sum = 0;
for (var item in array) {
  sum += item;
}

 
let sum = 0;for (var item in array) {  sum += item;}

forEach
let sum = 0; array.forEach(function(item, index) { sum += item; });
let sum = 0;
array.forEach(function(item, index) {
sum += item;
});

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
for
for each
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for	15899.5 Ops/sec
for each	15125.4 Ops/sec
forEach	385418.9 Ops/sec

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

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

The test measures the performance of three different ways to sum up an array of numbers using JavaScript: for, for each (also known as forEach), and another implementation for comparison purposes (...). We will assume that it is another implementation, but its name isn't specified.

Here are the options being compared:

For Loop: This is a traditional way to iterate over an array in JavaScript. It uses a counter variable to keep track of the current index, and checks if the loop has reached the end of the array.
For Each Loop (forEach): This is another way to iterate over an array, but it's more concise and doesn't require a manual index variable. Instead, it passes each element in the array as an argument to the callback function.
Assumed alternative implementation: We'll call this one "Alternative". Its name isn't specified.

Here are the pros and cons of each approach:

For Loop:
- Pros: Simple and well-understood by developers, easy to implement.
- Cons: Can be slower for large arrays due to overhead from indexing, not as concise as other options.
For Each Loop (forEach):
- Pros: More concise, doesn't require manual index variable, can be faster due to optimized implementation in modern browsers.
- Cons: May have some overhead due to function call and argument passing, less control over iteration process.
Alternative:
- Pros: Unknown performance characteristics, might offer better performance or features not available in other options.
- Cons: Lack of information about its specific behavior or implementation.

Now, let's talk about the library used in this benchmark. There is no library mentioned explicitly. However, it seems that some basic JavaScript functionality is assumed to be available, such as arrays and loops.

Finally, there are no special JavaScript features or syntax being tested here.

The other alternatives for measuring array sum performance would likely include:

Using a different iteration method, such as map or reduce.
Using a library like Lodash or Ramda that provides optimized functions for common tasks.
Measuring performance using a test runner like Jest or Mocha instead of a simple benchmarking framework.

However, it's worth noting that the specific use case and requirements of the project may influence the choice of alternative approaches.

LLMs can make mistakes. Check important info.

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

The test measures the performance of three different ways to sum up an array of numbers using JavaScript: `for`, `for each` (also known as `forEach`), and another implementation for comparison purposes (`...`). We will assume that it is another implementation, but its name isn't specified.

Here are the options being compared:

1. **For Loop**: This is a traditional way to iterate over an array in JavaScript. It uses a counter variable to keep track of the current index, and checks if the loop has reached the end of the array.
2. **For Each Loop** (`forEach`): This is another way to iterate over an array, but it's more concise and doesn't require a manual index variable. Instead, it passes each element in the array as an argument to the callback function.
3. **Assumed alternative implementation**: We'll call this one "Alternative". Its name isn't specified.

Here are the pros and cons of each approach:

* **For Loop**:
	+ Pros: Simple and well-understood by developers, easy to implement.
	+ Cons: Can be slower for large arrays due to overhead from indexing, not as concise as other options.
* **For Each Loop (`forEach`)**:
	+ Pros: More concise, doesn't require manual index variable, can be faster due to optimized implementation in modern browsers.
	+ Cons: May have some overhead due to function call and argument passing, less control over iteration process.
* **Alternative**:
	+ Pros: Unknown performance characteristics, might offer better performance or features not available in other options.
	+ Cons: Lack of information about its specific behavior or implementation.

Finally, there are no special JavaScript features or syntax being tested here.

The other alternatives for measuring array sum performance would likely include:

* Using a different iteration method, such as `map` or `reduce`.
* Using a library like Lodash or Ramda that provides optimized functions for common tasks.
* Measuring performance using a test runner like Jest or Mocha instead of a simple benchmarking framework.

However, it's worth noting that the specific use case and requirements of the project may influence the choice of alternative approaches.

Related benchmarks:

for/for each/forEach array sum (version: 0)

Comparing performance of: for vs for each vs forEach

Created: 2 years ago by: Guest

Jump to the latest result

for