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
}

AخA
 
let c = 0const 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]
}

 
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]
}

 
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ]const length = testArray.lengthconst 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]
}

​x
 
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]
}

 
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ]let i = testArray.lengthconst 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]
}

 
const testArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ]let i = -1const 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()

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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 5 months ago):

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:

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

Pros and Cons of each approach:

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

Results:

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

Length-based for loop (46811652 executions per second)
For loop with index (40141140 executions per second)
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.

LLMs can make mistakes. Check important info.

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

**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