Benchmark: array iteration SMALL3

Script Preparation code:

var myArraySmall = Array(3);
for (let i=0; i<3; i++) {
	myArraySmall[i] = i; 
}

Tests:

for element of SMALL
for (ele of myArraySmall) { let something = ele; }
for const element of SMALL
for (const ele of myArraySmall) { let something = ele; }
myArr forEach SMALL
myArraySmall.forEach(function(s) { let something = s; });
array index SMALL
for (let i=0; i<3; i++) { let something = myArraySmall[i]; }
map
myArraySmall.map((i) => { let something = i; });
forEach ES6 SMALL
myArraySmall.forEach(s => { let something = s; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for element of SMALL
for const element of SMALL
myArr forEach SMALL
array index SMALL
map
forEach ES6 SMALL

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 29 days ago):

LLMs can make mistakes. Check important info.

This benchmark on MeasureThat.net compares different ways to iterate over a small array (`myArraySmall` containing 3 elements) in JavaScript.  Let's break down each test case:

**Test Case Options:**

1. **`for (ele of myArraySmall)`**: This uses the modern `for...of` loop, designed specifically for iterating over iterable objects like arrays. It's concise and often the most readable option.

2. **`for (const ele of myArraySmall)`**: Similar to the above but explicitly declares each element as `const`, promoting immutability. This can be beneficial for clarity and preventing accidental reassignments within the loop.

3. **`myArraySmall.forEach(function(s) { ... })`**:  This uses the `.forEach()` array method, which executes a provided function for each element in the array. It's functional in style and may be preferred if you need to perform side effects or modify elements within the loop.

4. **`for (let i=0; i<3; i++) { ... }`**: This classic `for` loop uses an index (`i`) to access each element of the array directly using `myArraySmall[i]`. While functional, it can be less readable than the other options for iterating over arrays.

5. **`myArraySmall.map((i) => { ... })`**:  The `.map()` method creates a new array by applying a function to each element of the original array. While similar in concept to `forEach`, it returns a transformed array as its output.

6. **`myArraySmall.forEach(s => { ... })`**: This is essentially the same as the `.forEach()` using a traditional function, but utilizes arrow functions (`=>`) for a more concise syntax introduced in ES6 (ECMAScript 2015).

**Pros and Cons:**

* **`for...of` and `for const...of`**:
    * **Pros:**  Concise, readable, designed for iterating arrays.
    * **Cons:** Can be slightly slower than traditional loops in some cases.

* **`.forEach()`**:
    * **Pros:** Functional style, convenient for side effects or transformations.
    * **Cons:** Doesn't return a new array (unless you use `map`).

* **`for` loop with index**:
    * **Pros:**  Direct access to elements using indices, potentially faster than other methods.
    * **Cons:** Less readable and can be error-prone if not carefully managed.

* **`.map()`**: 
    * **Pros:** Returns a new array with transformed values. 
    * **Cons:** Can be more verbose if you don't need to create a new array, or if your transformation is simple.

**Alternatives:**

While these tests focus on basic iteration, other techniques exist for working with arrays:

* **`filter()`**: Creates a new array containing only elements that pass a condition.
* **`reduce()`**:  Applies a function cumulatively to each element of an array, returning a single value.

Let me know if you have any more questions about these test cases or JavaScript array manipulation in general!

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0

Browser/OS: Firefox 66 on Windows 7

View result in a separate tab

Test name	Executions per second
for element of SMALL	7568435.5 Ops/sec
for const element of SMALL	15427500.0 Ops/sec
myArr forEach SMALL	50719700.0 Ops/sec
array index SMALL	35450744.0 Ops/sec
map	18077240.0 Ops/sec
forEach ES6 SMALL	52956176.0 Ops/sec

Related benchmarks:

array iteration SMALL3 (version: 9)

Comparing performance of: for element of SMALL vs for const element of SMALL vs myArr forEach SMALL vs array index SMALL vs map vs forEach ES6 SMALL

Created: 6 years ago by: Registered User

Jump to the latest result

for element of SMALL

for const element of SMALL

myArr forEach SMALL

array index SMALL

map

forEach ES6 SMALL

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 29 days ago):