Benchmark: for vs forEach vs for in vs for of vs lodash vs for reverse (3)

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.15/lodash.min.js"></script>

Script Preparation code:

var arr = [];

function doMath(a) {
  return Math.log(a);
}

for(i=0; i<100; i++){
  arr[i] = i + 1;
}

Tests:

forEach
let sum = 0; arr.forEach((value) => { sum += doMath(value); });
for in
let sum = 0; for(const index in arr) { sum += doMath(arr[index]); }
for
let sum = 0; for(var i = 0; i < arr.length; i++) { const value = arr[i]; sum += doMath(value); }
for of
let sum = 0; for(const value of arr) { sum += doMath(value); }
lodash foreach
let sum = 0; _.forEach(arr, (value) => { sum += doMath(value); });
for reverse
let sum = 0; for(var i = arr.length - 1; i >= 0; i--) { const value = arr[i]; sum += doMath(value); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for in
for
for of
lodash foreach
for reverse

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what's being tested.

**Benchmark Overview**

The benchmark compares six different iteration methods in JavaScript:

1. `for`
2. `forEach` (native)
3. `for...in` (native)
4. `for...of` (native)
5. `lodash.forEach` (using the Lodash library)
6. `for reverse` (reversing the iteration order)

**Iteration Methods**

Here's a brief explanation of each method:

1. **Native `for`**: The traditional `for` loop with an index variable.
2. **`forEach` (native)**: A modern, concise way to iterate over arrays using a callback function.
3. **`for...in`**: An older, more verbose way to iterate over objects using their own property names as indices.
4. **`for...of`**: A newer, even more concise way to iterate over arrays and other iterable objects using a variable for the current value.
5. **`lodash.forEach`**: Using the Lodash library's `forEach` function to achieve the same result as native `forEach`.
6. **`for reverse`**: Reversing the iteration order by starting from the end of the array and moving backwards.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, string manipulation, and more. In this benchmark, `lodash.forEach` is used to mimic the behavior of native `forEach`, allowing for comparison between the two.

**Special Features/ Syntax**

There are no special features or syntaxes being tested in this benchmark. However, it's worth noting that `for...of` and `for...in` use specific syntaxes that have been introduced in newer versions of JavaScript.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each iteration method:

1. **Native `for`**:
	* Pros: Control over index, readability.
	* Cons: More verbose, potential for off-by-one errors.
2. **`forEach` (native)**:
	* Pros: Concise, easy to read, modern syntax.
	* Cons: Less control over iteration, may not work with non-array iterables.
3. **`for...in`**:
	* Pros: Allows iteration over object properties, can be useful in certain scenarios.
	* Cons: More verbose, potential for property name conflicts.
4. **`for...of`**:
	* Pros: Concise, easy to read, modern syntax, works with arrays and other iterables.
	* Cons: Less control over iteration, may not work with non-array iterables.
5. **`lodash.forEach`**:
	* Pros: Mimics native `forEach`, allows for comparison between the two.
	* Cons: Adds external dependency (Lodash), more verbose than native `forEach`.
6. **`for reverse`**:
	* Pros: Allows reversal of iteration order, can be useful in certain scenarios.
	* Cons: More complex to implement, potential performance overhead.

**Other Alternatives**

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

1. **Map**: The `map` function returns a new array with the results of applying a provided function to each element in the original array.
2. **Reduce**: The `reduce` function applies a provided function to each element in an array and reduces it to a single value.
3. **Filter**: The `filter` function creates a new array with all elements that pass the test implemented by a provided function.

These alternatives may offer different trade-offs in terms of conciseness, readability, and performance, depending on your specific use case.

Related benchmarks:

for vs forEach vs for in vs for of vs lodash vs for reverse (3) (version: 0)

for vs forEach vs for in vs for of vs lodash vs for reverse

Comparing performance of: forEach vs for in vs for vs for of vs lodash foreach vs for reverse

Created: 6 years ago by: Guest

Jump to the latest result

forEach

for in

for

for of

lodash foreach

for reverse

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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