Benchmark: Comparing sum of array elements between Native and lodash and some more for loops

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var size = 1000000;

var arr = [];

for(i=0; i<size; i++){
	arr.push(i);
}

Tests:

Native array
var sum = 0; for(i=0; i<arr.length; i++){ sum += arr[i]; } console.log(sum);
lodash array
var sum = 0; _.forEach(arr, function (element) { sum += element; }); console.log(sum);
Native foreach
var sum = 0; arr.forEach(value => { sum += value; }); console.log(sum);
Native for of
var sum = 0; for(const value of arr) { sum += value; } console.log(sum);
Native for in
var sum = 0; for(let x in arr) { sum += arr[x]; } console.log(sum);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native array
lodash array
Native foreach
Native for of
Native for in

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its results.

**Benchmark Overview**

The benchmark compares the performance of different JavaScript approaches to calculate the sum of elements in an array:

1. Native array using a traditional `for` loop
2. Lodash library with its `forEach` method
3. Native foreach (with `arr.forEach`)
4. Native for-of (with `for...of`)
5. Native for-in (with `for...in`)

**Options Compared**

The benchmark compares the performance of five different approaches:

* Traditional `for` loop (Native array)
* Lodash library with its `forEach` method (Lodash array)
* Native foreach (using `arr.forEach`)
* Native for-of (using `for...of`)
* Native for-in (using `for...in`)

**Pros and Cons of Each Approach**

1. **Traditional `for` loop (Native array)**: This approach is straightforward and easy to understand, but it can be slow due to the overhead of the loop control.
2. **Lodash library with its `forEach` method (Lodash array)**: Lodash provides a convenient way to perform common operations like iterating over arrays. However, using a third-party library may introduce additional overhead.
3. **Native foreach (using `arr.forEach`)**: This approach is concise and easy to read, but it's not as widely supported as other methods, and some older browsers may not have this method available.
4. **Native for-of (using `for...of`)**: This approach is a modern and efficient way to iterate over arrays, but it requires support for the `for...of` syntax.
5. **Native for-in (using `for...in`)**: This approach can be slow due to the overhead of iterating over the array's properties.

**Library Used**

The benchmark uses the Lodash library version 4.17.5. Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like string manipulation, array iteration, and more.

**Special JS Feature or Syntax**

None of the test cases use any special JavaScript features or syntax beyond what's standard in modern browsers. However, it's worth noting that some older browsers may not support certain syntax features like `for...of` or Lodash methods.

**Other Alternatives**

If you're looking for alternative ways to iterate over arrays or perform common operations, here are a few options:

* **Array.prototype.reduce()**: This method can be used to reduce an array to a single value.
* **Array.prototype.map()**: This method can be used to create a new array with transformed values.
* **ES6 array methods**: Modern browsers support various ES6 array methods like `map()`, `filter()`, and `reduce()`.

Keep in mind that the choice of approach depends on the specific use case, performance requirements, and personal preference.

Latest run results:

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

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

Browser/OS: Firefox 106 on Ubuntu

View result in a separate tab

Test name	Executions per second
Native array	20.0 Ops/sec
lodash array	122.6 Ops/sec
Native foreach	120.7 Ops/sec
Native for of	181.3 Ops/sec
Native for in	3.2 Ops/sec

Related benchmarks:

Comparing sum of array elements between Native and lodash and some more for loops (version: 1)

Comparing performance of: Native array vs lodash array vs Native foreach vs Native for of vs Native for in

Created: 3 years ago by: Registered User

Jump to the latest result

Native array

lodash array

Native foreach

Native for of

Native for in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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