Benchmark: js array copy speed comparison 2

Tests:

map
const arr = [1,2,3,4,5] const newArr = arr.map(e=>e)
array.from
const arr = [1,2,3,4,5] const newArr = Array.from(arr)
for loop
const arr = [1,2,3,4,5] let newArr = []; for(let i = 0; i < arr.length; i++) { newArr[i] = arr[i]; }
foreach
const arr = [1,2,3,4,5] let newArr = [] arr.forEach(e => { newArr.push(e) })
slice
const arr = [1,2,3,4,5] const newArr = arr.slice()
spread
const arr = [1,2,3,4,5] const newArr = [ ...arr ]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map
array.from
for loop
foreach
slice
spread

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
map	30028442.0 Ops/sec
array.from	3966581.5 Ops/sec
for loop	22481798.0 Ops/sec
foreach	23217018.0 Ops/sec
slice	59442456.0 Ops/sec
spread	38830696.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided JSON defines a benchmark that compares the performance of six different methods for creating a new array: `map`, `array.from`, `for loop`, `foreach`, `slice`, and `spread`. The test cases are identical, with the only difference being the method used to create the new array.

**What is tested?**

The benchmark tests the execution speed of each method on an array of five elements. The methods are compared in terms of their performance, measured in executions per second (ExecutionsPerSecond).

**Options Compared**

1. `map()`: Creates a new array by applying a provided function to each element of the original array.
2. `array.from()`: Creates a new array from an existing iterable object, such as an array or string.
3. `for loop`: Iterates over the elements of the original array using a traditional for loop and assigns each value to a new array.
4. `foreach` ( likely a typo, it should be "forEach"): Similar to `map()`, but uses the `forEach()` method instead.
5. `slice()`: Creates a shallow copy of a portion of an array, starting from the specified index.
6. `spread` ( likely referring to Array.prototype spread syntax): Creates a new array by spreading the elements of an existing iterable object.

**Pros and Cons**

1. **map()**: Pros: concise, readable code; Cons: can be slower due to function creation and execution.
2. **array.from()**: Pros: creates a shallow copy, which might be useful in certain scenarios; Cons: can be slower than `slice()` or `spread`.
3. **for loop**: Pros: control over iteration; Cons: verbose, error-prone code.
4. **foreach** ( corrected to "forEach"): Pros: concise, readable code; Cons: similar performance characteristics to `map()`.
5. **slice()**: Pros: fast and efficient; Cons: creates a shallow copy, which might not be suitable for all use cases.
6. **spread** ( corrected to "Array.prototype spread syntax"): Pros: concise, modern syntax; Cons: can be slower than `slice()` or other methods.

**Library Usage**

None of the test cases explicitly uses any external libraries.

**Special JS Feature/Syntax**

The benchmark uses the following features:

1. Arrow functions (`e => e`) in `map()`.
2. `Array.from()` and `spread` syntax.
3. Traditional for loop in `for loop`.

These features are not specific to JavaScript version or platform, but might be more common in modern development environments.

**Alternatives**

Other methods for creating a new array include:

1. Using the `concat()` method: `const newArr = arr.concat();`
2. Using the `push()` method with an array: `const newArr = []; newArr.push(...arr);`
3. Using a custom reducer function in `reduce()`: `const newArr = arr.reduce((acc, e) => acc.concat(e), [])`

These alternatives might have different performance characteristics and use cases compared to the methods tested in this benchmark.

Related benchmarks:

js array copy speed comparison 2 (version: 0)

Comparing performance of: map vs array.from vs for loop vs foreach vs slice vs spread

Created: one year ago by: Registered User

Jump to the latest result

map

array.from

for loop

foreach

slice

spread

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