Benchmark: bunch of array copy approaches

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

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

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript array copy approaches.

**What is being tested?**

The benchmark measures the performance of different approaches to create a new array by copying an existing one. The test cases vary in their syntax, approach, and library usage.

**Approaches compared:**

1. **For...of loop**: This approach uses a for-of loop to iterate over the original array and push each element into a new array.
2. **For...in loop**: This approach uses a for-in loop to iterate over the original array's indices and assign each value to a corresponding index in the new array.
3. **Index-based iteration**: This approach uses a traditional for loop with an index variable to access elements in the original array and push them into the new array.
4. **Incrementing index**: Similar to index-based iteration, but the index is incremented before accessing the next element.

**Pros and Cons:**

1. **For...of loop**:
	* Pros: concise syntax, easy to read, and maintainable.
	* Cons: might be slower due to the overhead of iterating over the array's entries.
2. **For...in loop**:
	* Pros: uses indices, which can lead to faster access times for arrays with a small number of elements.
	* Cons: less readable than for-of loops, and the syntax is more verbose.
3. **Index-based iteration**:
	* Pros: provides fine-grained control over indexing, allowing for optimization opportunities.
	* Cons: requires explicit index management, which can add complexity to the code.
4. **Incrementing index**:
	* Pros: similar to index-based iteration but with an incrementing index, potentially leading to better performance.
	* Cons: still requires explicit index management.

**Library usage and other considerations:**

There is no library used in this benchmark, as all test cases rely on built-in JavaScript features.

**Special JS feature or syntax:**

None mentioned. All approaches use standard JavaScript syntax.

**Benchmark results analysis:**

The latest benchmark result shows that:

* For...of loop and for...in loop approaches are slower compared to the other two index-based approaches.
* The incrementing index approach provides better performance than traditional index-based iteration.

**Other alternatives:**

1. **Array.prototype.slice()**: A built-in method that creates a shallow copy of an array, potentially offering good performance.
2. **Array.prototype.map()**: Another built-in method that creates a new array by applying a transformation function to each element in the original array.
3. **Array.prototype.splice()**: Can be used to create a new array by iterating over the original array and pushing elements into the new array.

These alternatives may provide different performance characteristics depending on the specific use case, and some might be more suitable than others for certain scenarios.

Related benchmarks:

bunch of array copy approaches (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

Created: 3 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

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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