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 David WalshMay 6, 2015
I’m an Impostor
This is the hardest thing I've ever had to write, much less admit to myself. I've written resignation letters from jobs I've loved, I've ended relationships, I've failed at a host of tasks, and let myself down in my life. All of those feelings were very...
By David WalshJuly 15, 2013
9 Mind-Blowing WebGL Demos
As much as developers now loathe Flash, we're still playing a bit of catch up to natively duplicate the animation capabilities that Adobe's old technology provided us. Of course we have canvas, an awesome technology, one which I highlighted 9 mind-blowing demos. Another technology available...

Incredible Demos

By David WalshJune 29, 2009
Highlighter: A MooTools Search & Highlight Plugin
Searching within the page is a major browser functionality, but what if we could code a search box in JavaScript that would do the same thing? I set out to do that using MooTools and ended up with a pretty decent solution. The MooTools JavaScript Class The...
By David WalshJanuary 7, 2009
CSS Fixed Positioning
When you want to keep an element in the same spot in the viewport no matter where on the page the user is, CSS's fixed-positioning functionality is what you need. The CSS Above we set our element 2% from both the top and right hand side of the...

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

I’m an Impostor

9 Mind-Blowing WebGL Demos