Benchmark: for of over a small array

Script Preparation code:

function meow() {
  return [1, 2, 42, 52];
  
}

Tests:

native for of
const foo = meow() foo.push(1337); let blah; for (let i of foo) { blah = i; }
babel for of
const foo = meow(); foo.push(1337); let blah; var _iteratorNormalCompletion = true; var _didIteratorError = false; var _iteratorError = undefined; try { for (var _iterator = foo[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { let i = _step.value; blah = i; } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } }
babel for of loose
var foo = meow(); foo.push(1337); let blah; for (var _iterator = foo, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { var _ref; if (_isArray) { if (_i >= _iterator.length) break; _ref = _iterator[_i++]; } else { _i = _iterator.next(); if (_i.done) break; _ref = _i.value; } var i = _ref; blah = i; }
indexed for loop
const foo = meow() foo.push(1337); let blah; for (let k = 0; k < foo.length; k++) { blah = foo[k]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native for of
babel for of
babel for of loose
indexed for loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll dive into the explanation.

**Overview**

The provided benchmark measures the performance of three different approaches to iterate over an array: `for...of`, `var for` with `Symbol.iterator`, and `indexed for loop`.

**Options compared**

1. **Native `for...of`**: This approach uses the new `for...of` syntax, introduced in ECMAScript 2015 (ES6). It allows iterating over arrays and other iterable objects without the need to define an iterator function.
2. **Babel `var for` with `Symbol.iterator`**: This approach uses the old `for` loop syntax with the `var` keyword and explicitly defines an iterator using the `Symbol.iterator` property.
3. **Indexed `for loop`**: This approach uses a traditional `for` loop with array indices to iterate over the elements of the array.

**Pros and Cons**

1. **Native `for...of`**:
	* Pros: concise, expressive, and modern syntax; automatically handles iteration over arrays and other iterable objects.
	* Cons: may have slower performance due to additional overhead for parser and execution engines.
2. **Babel `var for` with `Symbol.iterator`**:
	* Pros: allows for fine-grained control over iteration, which can be useful in some cases; compatible with older JavaScript engines that don't support `for...of`.
	* Cons: requires more code to define the iterator function, which can increase maintenance overhead.
3. **Indexed `for loop`**:
	* Pros: highly optimized for performance, as it directly accesses array elements using indices.
	* Cons: less expressive and less modern syntax; requires explicit handling of array bounds and indexing.

**Other considerations**

1. **Library usage**: The benchmark uses a custom JavaScript function `meow()` to create a small array with four elements. This is not relevant to the iteration approach being tested.
2. **Special JS features or syntax**: There are no special features or syntax used in this benchmark.

**Benchmark interpretation**

The benchmark measures the performance of each iteration approach on a desktop Chrome 79 browser with Linux operating system. The results show that:

* Indexed `for loop` performs the fastest, followed by native `for...of`, and then Babel `var for` with `Symbol.iterator`.
* Native `for...of` has relatively high execution rates (9275427.0/s, 8785168.0/s) on desktop Chrome.
* Babel `var for` with `Symbol.iterator` performs slower than native `for...of`, but still competitive.

Keep in mind that these results are specific to the benchmarked environment and may vary depending on other factors such as system load, network latency, or specific use cases.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Linux

View result in a separate tab

Test name	Executions per second
native for of	8785168.0 Ops/sec
babel for of	2928336.8 Ops/sec
babel for of loose	4805048.0 Ops/sec
indexed for loop	9275427.0 Ops/sec

Related benchmarks:

for of over a small array (version: 0)

Comparing performance of: native for of vs babel for of vs babel for of loose vs indexed for loop

Created: 4 years ago by: Guest

Jump to the latest result

native for of

babel for of

babel for of loose

indexed for loop

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):