Benchmark: Map vs Vanilla For vs For Of

Script Preparation code:

var objects = [{
  "key1": 'hello'
}, {
  "key2": 'bye'
}, {
  "key3": 'olleh'
}, {
  "key4": 'eyb'
}];

Tests:

Map with clone
objects.map((obj) => { obj = Object.assign({}, obj); obj.group = 'grouping'; return obj; })
Map
objects.map((obj) => { obj.group = 'grouping'; return obj; })
Vanilla For
for (let i = 0; i < objects.length; i++) { objects[i].group = 'grouping'; }
For Of
for (const obj of objects) { obj.group = 'grouping'; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map with clone
Map
Vanilla For
For Of

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in this benchmark.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares the performance of three different approaches:

1.  **`map()` method**: A built-in JavaScript array method that creates a new array with the results of applying an provided function on every element in the calling array.
2.  **Vanilla `For` loop**: An iterative approach using a traditional `for` loop to iterate over the elements of the array.
3.  **`For Of` loop**: A modern JavaScript feature that allows iterating over arrays using a `for...of` loop.

**Options Comparison**

The three options are compared in terms of:

*   Execution speed
*   Memory usage (not directly shown in the JSON, but can be inferred by analyzing the benchmark results)
*   Code simplicity and readability

**Pros and Cons of Each Approach**

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

1.  **`map()` method**:
    *   Pros: Efficient, concise, and easy to read.
    *   Cons: May require additional memory allocation (if the resulting array is not sparse) and can be slower due to garbage collection.

2.  **Vanilla `For` loop**:
    *   Pros: Control over iteration variables, no memory allocation concerns, and potentially faster execution speed since it avoids the overhead of the `map()` method.
    *   Cons: More verbose code, less readable, and requires manual indexing.

3.  **`For Of` loop**:
    *   Pros: Modern, concise, and easy to read. It also provides better iteration support (e.g., no need for manual indexing).
    *   Cons: May be slower than the `for` loop due to potential overhead from modern JavaScript features, and some older browsers may not support it.

**Library Usage**

There is no explicit library usage mentioned in the benchmark JSON.

**Special JS Features or Syntax**

The benchmark utilizes:

*   **`Object.assign()` method**: Used within the `map()` callback function to clone objects. This method creates a shallow copy of an object.
*   **`For Of` loop**: A modern JavaScript feature that allows iterating over arrays using a `for...of` loop.

**Other Alternatives**

Alternative approaches to compare might include:

*   Using `forEach()` instead of `map()`
*   Employing traditional iteration methods (e.g., `indices.forEach()`)
*   Leveraging modern array utilities (e.g., `array.prototype.reduce()`, `Array.from()`)

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36

Browser/OS: Chrome 75 on Mac OS X 10.14.5

View result in a separate tab

Test name	Executions per second
Map with clone	1036776.8 Ops/sec
Map	5493216.5 Ops/sec
Vanilla For	1325288.9 Ops/sec
For Of	9052576.0 Ops/sec

Related benchmarks:

Map vs Vanilla For vs For Of (version: 0)

Comparing performance of: Map with clone vs Map vs Vanilla For vs For Of

Created: 5 years ago by: Guest

Jump to the latest result

Map with clone

Map

Vanilla For

For Of

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):