Benchmark: bunch of array copy v2

Tests:

for i of
let c = 0 const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] const newArray = [] for (const i of testArray) { newArray[c++] = i }
for i in
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] const newArray = [] for (const i in testArray) { newArray[i] = testArray[i] }
for i length first
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] const length = testArray.length const newArray = [] for (let i = 0; i < length; i++) { newArray[i] = testArray[i] }
for i length every
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] const newArray = [] for (let i = 0; i < testArray.length; i++) { newArray[i] = testArray[i] }
while crazy
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] let i = testArray.length const newArray = [] while (~--i) { newArray[i] = testArray[i] }
while boring
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] let i = -1 const newArray = [] while (i++ < testArray.length) { newArray[i] = testArray[i] }
slice
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] const newArray = testArray.slice()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for i of
for i in
for i length first
for i length every
while crazy
while boring
slice

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36

Browser/OS: Chrome 104 on Windows

View result in a separate tab

Test name	Executions per second
for i of	38362428.0 Ops/sec
for i in	2054274.6 Ops/sec
for i length first	46811652.0 Ops/sec
for i length every	47680224.0 Ops/sec
while crazy	40141140.0 Ops/sec
while boring	39310488.0 Ops/sec
slice	200015872.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript array copying benchmarks.

The provided JSON represents a benchmarking framework where users can create and run JavaScript microbenchmarks. The benchmark being tested is related to copying an array, with various approaches compared.

**What are we testing?**

We're testing different ways to copy an array in JavaScript. The array contains 10 elements, and the goal is to determine which approach is the fastest.

**Options compared:**

There are four main approaches compared:

1. **For loop with index**: Using a traditional `for` loop with an incrementing index (`c++ = i`) to iterate over the array.
2. **For loop with `in` keyword**: Using the `in` keyword to access array elements.
3. **Length-based `for` loop**: Using a `for` loop that iterates from 0 to the length of the array.
4. **Every element iteration**: Using another `for` loop that iterates over each element in the array.
5. **While loop with decrementing index**: Using a `while` loop with a decrementing index (`--i`) to iterate over the array.
6. **Array slicing**: Using the `slice()` method to create a new array.

**Pros and Cons of each approach:**

1. **For loop with index**:
	* Pros: Simple and efficient.
	* Cons: Can lead to off-by-one errors if not implemented correctly.
2. **For loop with `in` keyword**:
	* Pros: Convenient, but may be slower due to overhead.
	* Cons: Can be less predictable than traditional indexing.
3. **Length-based `for` loop**:
	* Pros: Avoids potential off-by-one errors and is often faster.
	* Cons: May require more iterations.
4. **Every element iteration**:
	* Pros: Provides equal access to all elements, but may be slower due to unnecessary iterations.
	* Cons: Can lead to increased overhead.
5. **While loop with decrementing index**:
	* Pros: Efficient and can avoid off-by-one errors.
	* Cons: May require more complex indexing logic.
6. **Array slicing**:
	* Pros: Convenient, but may lead to unnecessary memory allocation.

**Results:**

The benchmark results show that the following approaches are the fastest:

1. Length-based `for` loop (`46811652` executions per second)
2. For loop with index (`40141140` executions per second)
3. While loop with decrementing index (`39310488` executions per second)

Note that these results may vary depending on the specific implementation, browser, and environment.

**Conclusion:**

The benchmark results suggest that the length-based `for` loop is the fastest approach for copying an array in JavaScript. This method provides a good balance between efficiency and predictability. However, it's essential to consider the specific use case and potential trade-offs when choosing an approach.

Related benchmarks:

bunch of array copy v2 (version: 0)

bunch of array copy approaches

Comparing performance of: for i of vs for i in vs for i length first vs for i length every vs while crazy vs while boring vs slice

Created: 2 years ago by: Guest

Jump to the latest result

for i of

for i in

for i length first

for i length every

while crazy

while boring

slice

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):