Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Creation of new Array: Array.from vs. new Array
(version: 0)
Comparing performance of:
Array.from vs new Array
Created:
4 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var size = 5000;
Tests:
Array.from
const arr = Array.from({ length: size });
new Array
const arr = new Array(size);
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Array.from
new Array
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one month ago
)
User agent:
Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36
Browser/OS:
Chrome 149 on Linux
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=632817" width="100%" height="500px"></iframe>
new Array
259.1M/s
Array.from
10K/s
View exact numbers
Test name
Executions per second
✓
new Array
259,131,616 Ops/sec
Array.from
10,226 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the JavaScript microbenchmark on MeasureThat.net. **Benchmark Overview** The benchmark compares two approaches for creating new JavaScript arrays: `Array.from()` and the traditional `new Array()`. The goal is to measure which approach is faster, more efficient, or both. **Options Compared** Two options are being compared: 1. **`Array.from({ length: size })`**: This method creates a new array by mapping an array with `length` property to create the desired number of elements. 2. **`new Array(size)`**: This method creates a new array using the constructor syntax, where `size` is the initial length of the array. **Pros and Cons** Here's a brief overview of each approach: * **`Array.from()`**: Pros: * More concise and readable syntax. * Can create arrays from other iterables (e.g., strings, sets). Cons: * May have performance overhead due to function call and mapping process. * **`new Array(size)`**: Pros: * Faster execution time since it avoids the function call and mapping overhead. Cons: * Less readable and more verbose syntax. **Library** There is no specific library being used in this benchmark. The `Array.from()` method is a built-in JavaScript method, while the `new Array(size)` approach relies on the constructor syntax. **Special JS Feature or Syntax** Neither of the approaches uses any special JavaScript feature or syntax. Both are standard ES6+ features. **Other Alternatives** If you're interested in exploring other alternatives for creating arrays, here are a few options: 1. **`Array.create()`**: This method is similar to `new Array(size)` but returns an array object instead of an array constructor. 2. **`Array.prototype.slice()`**: You can create an array by calling the `slice()` method on an existing array and specifying the desired length. Here's some sample code demonstrating these alternatives: ```javascript // Array.create() var arr1 = Array.create(10); console.log(arr1.length); // Output: 10 // Array.prototype.slice() var arr2 = [1, 2, 3]; var newarr = arr2.slice(0, 5); console.log(newarr.length); // Output: 5 ``` Keep in mind that the performance characteristics of these alternatives might differ from `new Array(size)` and `Array.from()`, so be sure to benchmark them if necessary.
Related benchmarks
Array.from() vs new Array()
Array.from() vs new Array() - empty
Array.from({ length: n }) vs new Array(n)
Comments
Confirm delete:
Do you really want to delete benchmark?