Building Resilient Systems on AWS: Learn how to design and implement a resilient, highly available, fault-tolerant infrastructure on AWS.

Array.From

By David Walsh on February 12, 2016

In the past we used a variety of hacks to convert Array-like objects (like arguments and NodeList) to a true array. You can see a few of those hacks here:

Essentially we would use Array.prototype.slice.call() on the arguments or NodeList to do the conversion. These days there is a more straightforward solution to converting one type to another.

Convert `NodeList` to `Array`

var divs = Array.from(document.querySelectorAll('div'));

// Array[232] (every DIV on the page)

Convert `arguments` to `Array`

function something() {
  var args = Array.from(arguments);

  // Array['yes', 1, {}]
}
something('yes', 1, {});

Convert `String` to `Array`

Array.from('JavaScript'); // Same as 'JavaScript'.split('')

// ["J", "a", "v", "a", "S", "c", "r", "i", "p", "t"]

The code is much cleaner and no need for the slice hack!

Recent Features

By Chris CoyierJune 30, 2015
Chris Coyier’s Favorite CodePen Demos II
Hey everyone! Before we get started, I just want to say it's damn hard to pick this few favorites on CodePen. Not because, as a co-founder of CodePen, I feel like a dad picking which kid he likes best (RUDE). But because there is just so...
By David WalshDecember 6, 2012
Vibration API
Many of the new APIs provided to us by browser vendors are more targeted toward the mobile user than the desktop user. One of those simple APIs the Vibration API. The Vibration API allows developers to direct the device, using JavaScript, to vibrate in...

Incredible Demos

By David WalshMarch 5, 2013
jQuery Wookmark
The first thing that hits you when you visit Pinterest is "Whoa, the columns are the same width and the photos are cut to fit just the way they should." Basic web users probably think nothing of it but as a developer, I can appreciate the...
By David WalshAugust 11, 2011
dat.gui: Exceptional JavaScript Interface Controller
We all love trusted JavaScript frameworks like MooTools, jQuery, and Dojo, but there's a big push toward using focused micro-frameworks for smaller purposes. Of course, there are positives and negatives to using them. Positives include smaller JS footprint (especially good for mobile) and less cruft, negatives...

Discussion

hexx
small note -> babel doesn’t transpile Array.from() – so keep that in mind to include it ;)

hexx
[].slice.call(stuff) isn’t much longer than Array.from(stuff)
XPoli
Array.apply(0, stuff) is also a good solution
Prashant Palikhe
It’s not about which one is shorter, Array.from is just more declarative approach to doing the same thing.
Evan
There’s a babel plug-in for Array.from()

https://babeljs.io/docs/usage/polyfill/

jide
When using ES6, you can use the spread operator with array-like objects like this :
```
const args = [...arguments];
const nodes = [...document.querySelectorAll('div')];
```
You can even use this with Sets, a cool trick to make an array unique :
```
const myUniqueArray = [...new Set(myArray)];
```

Aleksander Nowodziński

Instead of spread you could use rest operator:

function something( ...args ) {
  // Array['yes', 1, {}]
}
something('yes', 1, {});

Paul Fitzgerald

Is the section “Convert String to Array” definitely correct?

When I check the console I see the below:

'JavaScript'.split('')
Array [ "J", "a", "v", "a", "S", "c", "r", "i", "p", "t" ]
Array.from('JavaScript');
Array [ "JavaScript" ]

Espen
That’s actually a bit funny. If you run that code in dev tools opened from this article, the Array.from function is overwritten by MooTools, and no longer works like the “native” version.
```
Array.from = function(e) {
    return null  == e ? [] : o.isEnumerable(e) && "string" != typeof e ? "array" == t(e) ? e : s.call(e) : [e]
}
```
Run it in a new browser window and it should work.
freginold
Paul, did the same thing for me, but if I run the code somewhere else (tried it on repl.it) it works just as it’s supposed to.

David Walsh
What he said…old MooTools has it wrong. I’ll be removing MooTools and all frameworks from the site soon.
Peter Bengtsson
I built a site in reactjs with es6 recently. Standard stack (these days).
The damn thing wouldn’t work on old Android browsers and certain browser in WebPageTest. “TypeError: function is undefined” (or something like that).

Turns out these old browsers choked on the first occurrence of Array.from().

Adding babel-polyfill made my day.
Roni
What about performance, which one is the best approach??

Eric Guittiere
Looks like
```
Array.prototype.slice.call(arraylike);
```
is the fastest option (in Chrome and Firefox).
```
[...arraylike]
```
and
```
Array.apply(0, arraylike);
```
are second or third depending (different results in Chrome and FF), and unfortunately
```
Array.from(arraylike);
```
is the slowest by far on both browsers… :(

Array.From

Convert NodeList to Array

Convert arguments to Array

Convert String to Array

Recent Features

Chris Coyier’s Favorite CodePen Demos II

Vibration API