Merge/flatten an array of arrays

Question

I have a JavaScript array like:

[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]

How would I go about merging the separate inner arrays into one like:

["$6", "$12", "$25", ...]

Alderson

All of the solutions that use reduce + concat are O((N^2)/2) where as a accepted answer (just one call to concat) would be at most O(N*2) on a bad browser and O(N) on a good one. Also Denys solution is optimized for the actual question and upto 2x faster than the single concat. For the reduce folks it's fun to feel cool writing tiny code but for example if the array had 1000 one element subarrays all the reduce+concat solutions would be doing 500500 operations where as the single concat or simple loop would do 1000 operations. – Playacting

With the latest browsers that support ES2019: array.flat(Infinity) where Infinity is the maximum depth to flatten. – Eagle

I'm glad they put a maximum depth.. :D – Pawnbroker

Flatmap works like champ, try this. var d = [[1], [2], [3], [4,5,6]].flatMap(x => x); – Comprador

Answer 1

---

ES2019

ES2019 introduced the Array.prototype.flat() method which you could use to flatten the arrays. It is compatible with most environments, although it is only available in Node.js starting with version 11, and not at all in Internet Explorer.

const arrays = [
      ["$6"],
      ["$12"],
      ["$25"],
      ["$25"],
      ["$18"],
      ["$22"],
      ["$10"]
    ];
const merge3 = arrays.flat(1); //The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
console.log(merge3);
    

---

Older browsers

For older browsers, you can use Array.prototype.concat to merge arrays:

var arrays = [
  ["$6"],
  ["$12"],
  ["$25"],
  ["$25"],
  ["$18"],
  ["$22"],
  ["$10"]
];
var merged = [].concat.apply([], arrays);

console.log(merged);

Using the apply method of concat will just take the second parameter as an array, so the last line is identical to this:

var merged = [].concat(["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]);

Dinghy

Or Array.prototype.concat.apply([], arrays). – Hammond

Note: this answer only flattens one level deep. For a recursive flatten, see the answer by @Trindaz. – Anhydrite

Further to @Sean's comment: ES6 syntax makes this super concise: var merged = [].concat(...arrays) – Jut

Building on @Sethi's comment: Array.prototype.concat(...arrays). This version works with Typescript's 2.3.0 --strict mode. Doesn't work with nested arrays (it's not recursive). – Giamo

'apply' will stack overflow on large inputs for some vms, like v8. It's really not meant for this use case. – Eddins

as @Jut mentioned, for ES6: [].concat(...arrays) also works in Typescript – Wildman

Array.prototype.flat is now official! And supported in Chrome, Firefox, Opera, Safari! – Glottochronology

@Dinghy your solution will result 4,9, 5, , , 6, 4,5,5,7, 65, 56 for [[[4,9],5,null,[],6,[4,[5,5],7],65],56] whereas it should return may be 4,9, 5, null, 6, 4,5,5,7, 65, 56 or may be 4,9, 5, 6, 4,5,5,7, 65, 56 – Contumacious

On advantage over flat(): as of Nov 23, 2019, this works in Edge, while the prettier flat() does not. – Cimon

Can we use this method for any depth of arrays? It seems that this code runs only for 1-level nested array. – Cortney

Out of curiosity, why in var merged = [].concat.apply([], arrays);, thisArg is set to an empty array? – Aedile

Also worth checking that if you have more than one (flat) arrays. [].concat(arrayA, arrayB) – Punkie

If I use any of the various suggestions that start with []. I get an error back saying "Argument of type 'number[]' is not assignable to parameter of type 'ConcatArray<never>'. (I'm merging a 2-dimensional array of numbers.) The error resolves and I get the expected output if I change this to new Array().concat(...arrays) – Culmiferous

[].concat(...arrays).length this helped me do a count / empty check without changing original array. Thanks! – Senhauser

@Anhydrite you can delete your comment from 2014, flat() goes more levels deep. – Ruth

Answer 2

Here's a short function that uses some of the newer JavaScript array methods to flatten an n-dimensional array.

function flatten(arr) {
  return arr.reduce(function (flat, toFlatten) {
    return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
  }, []);
}

Usage:

flatten([[1, 2, 3], [4, 5]]); // [1, 2, 3, 4, 5]
flatten([[[1, [1.1]], 2, 3], [4, 5]]); // [1, 1.1, 2, 3, 4, 5]

Sacrificial

What's the memory usage profile for this solution? Looks like it creates a lot of intermediate arrays during the tail recursion.... – Llamas

Why is there an empty array passed as an argument? The code breaks without it, but what does it do? – Honeysucker

@ayjay, it's the starting accumulator value for the reduce function, what mdn calls the initial value. In this case it's the value of flat in the first call to the anonymous function passed to reduce. If it is not specified, then the first call to reduce binds the first value out of the array to flat, which would eventually result in 1 being bound to flat in both the examples. 1.concat is not a function. – Sacrificial

It is a nice solution and in most cases I would happily use it, but performance might not be the best: If you have for an array structure that has at the deepest child level a lot of values, it will still go through those even though it doesn't change them, so e.g. in the questions example it will go through all the arrays, not just the parent array. Even though it doesn't need to flatten anything else except the first tier. I had (naturally) performance issues with array structure of 10000+ arrays inside 2 parent arrays. – Maytime

Or in a shorter, sexier form: const flatten = (arr) => arr.reduce((flat, next) => flat.concat(next), []); – Dhruv

Riffing on @TsvetomirTsonev and Noah's solutions for arbitrary nesting: const flatten = (arr) => arr.reduce((flat, next) => flat.concat(Array.isArray(next) ? flatten(next) : next), []); – Paba

Bad memory profile, too many intermediate arrays, this answer will be rejected in most first-tier company interviews. – Gladstone

@GeorgeKatsanos We don't know that - yes, concat is supposed to create a new array, but the runtimes can optimize just like hey already do e.g. for lots of kinds of string operations. If they detect the array is immediately discarded, and they can even limit the detection to the reduce function specifically, they can reuse the same array internally. Fort your interviews, I would say anybody who thinks that the observable behavior of JS code always is exactly the same as what the runtime does internally should maybe not be rejected but definitely educated - this stuff may change any time. – Wolgast

I like the idea here but this will break if any of the original array values are not arrays – Rodolforodolph

I know that this is a super old answer, but I think it's great - so thank you for that Noah. However I have some trouble understanding what line number 3 does. As I understand it, it concats something to the accumulator but what exactly, the ternary operator kind of breaks my mind. I would really appreciate you giving me a hand! ^^ – Hotel

Answer 3

There is a confusingly hidden method, which constructs a new array without mutating the original one:

var oldArray = [[1],[2,3],[4]];
var newArray = Array.prototype.concat.apply([], oldArray);
console.log(newArray); // [ 1, 2, 3, 4 ]

Tirrell

I'm not really convinced that this is "performant" as I seem to have hit a stack overflow with this sort of call (on an array with 200K entries which are lines in a file). – Chancellorship

If you can use ES2015 you might also write it easier for the eye with array spreads: [].concat(...[ [1],[2,3],[4] ]). – Studhorse

did not work with array [2, [3, [4, [5, [6, [7, [8]]]]]]] – Siskin

Very clever approach, I like it! Extremely useful if you have to flatten an array inside of an array, since using apply would presume you are passing in an array of parameters. Only bummer is if you have arrays inside your array that are more than two levels deep. – Lucianolucias

I like this approach... here for n-dimensional arrays: flat = (e) => Array.isArray(e)? [].concat.apply([], e.map(flat)) : e – Somewhere

Answer 4

It can be best done by javascript reduce function.

var arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];

arrays = arrays.reduce(function(a, b){
     return a.concat(b);
}, []);

Or, with ES2015:

arrays = arrays.reduce((a, b) => a.concat(b), []);

js-fiddle

Mozilla docs

Megalo

Since you use ES6, you could also use the spread-operator as array literal. arrays.reduce((flatten, arr) => [...flatten, ...arr]) – Cottle

Answer 5

There's a new native method called flat to do this exactly.

(As of late 2019, flat is now published in the ECMA 2019 standard, and core-js@3 (babel's library) includes it in their polyfill library)

const arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

// Flatten 2 levels deep
const arr3 = [2, 2, 5, [5, [5, [6]], 7]];
arr3.flat(2);
// [2, 2, 5, 5, 5, [6], 7];

// Flatten all levels
const arr4 = [2, 2, 5, [5, [5, [6]], 7]];
arr4.flat(Infinity);
// [2, 2, 5, 5, 5, 6, 7];

Minimal

It's a shame this isn't even on the first page of answers. This feature is available in Chrome 69 and Firefox 62 (and Node 11 for those working in the backend) – Betray

And there’s developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Underlinen

-1; nope, this isn't part of ECMAScript 2018. It's still just a proposal that hasn't made it to any ECMAScript spec. – Haematin

I think now we can consider this .. because now it's part of standard (2019) .. can we revisit the performance part of this once ? – Hairbrush

Seems it's not yet supported by any Microsoft browser though (at least at the time I write this comment) – Hephzipah

As of Nov 23, 2019, flat() works in chrome but not in edge. See developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Cimon

Today, non-Chromium Edge is the only major browser that doesn't support flat(). But that's not a big deal, Chromium Edge is already available so you can tell your users to upgrade to it, and if nothing else the next Windows 10 update will include Chromium Edge by default. – Revisal

Fwiw, here's an unoptimized flat polyfill outside of babel. And then flatMap polyfill can be return Array.isArray(array) ? array.map(callback).flat() : array;. If you need map as well, MDN has a map poly. Or just transpile your code like most folk in 2020. ;^D – Procuration

Answer 6

Most of the answers here don't work on huge (e.g. 200 000 elements) arrays, and even if they do, they're slow.

Here is the fastest solution, which works also on arrays with multiple levels of nesting:

const flatten = function(arr, result = []) {
  for (let i = 0, length = arr.length; i < length; i++) {
    const value = arr[i];
    if (Array.isArray(value)) {
      flatten(value, result);
    } else {
      result.push(value);
    }
  }
  return result;
};

Examples

Huge arrays

flatten(Array(200000).fill([1]));

It handles huge arrays just fine. On my machine this code takes about 14 ms to execute.

Nested arrays

flatten(Array(2).fill(Array(2).fill(Array(2).fill([1]))));

It works with nested arrays. This code produces [1, 1, 1, 1, 1, 1, 1, 1].

Arrays with different levels of nesting

flatten([1, [1], [[1]]]);

It doesn't have any problems with flattening arrays like this one.

Contraception

Except your huge array is pretty flat. This solution won't work for deeply nested arrays. No recursive solution will. In fact no browser but Safari has TCO right now, so no recursive algorithm will perform well. – Aplanatic

@Aplanatic But in what real-world situation would you have arrays with more than a few levels of nesting? – Pak

Usually, when the array is generated out of user generated content. – Aplanatic

@0xcaff In Chrome it doesn't work at all with a 200 000-element array (you get RangeError: Maximum call stack size exceeded). For 20 000-element array it takes 2-5 milliseconds. – Pak

what's the O notation complexity of this? – Gladstone

@MichałPerłakowski i just tested this https://mcmap.net/q/36813/-merge-flatten-an-array-of-arrays with huge array and it works. – Monopetalous

@MichałPerłakowski But in what real-world situation would you have arrays with more than a few levels of nesting? -> When you design grammars, their parsers/lexers can generate deeply nested arrays easily. – Martinmas

You linked an answer which works for 1 level arrays: "polkovnikov.ph's answer". I don't see a user with this name and the link just takes me up to the question. Was it deleted? – Lazaretto

@HumanZeroHumanZero Yes. – Pak

Answer 7

Update: it turned out that this solution doesn't work with large arrays. It you're looking for a better, faster solution, check out this answer.

---

function flatten(arr) {
  return [].concat(...arr)
}

Is simply expands arr and passes it as arguments to concat(), which merges all the arrays into one. It's equivalent to [].concat.apply([], arr).

You can also try this for deep flattening:

function deepFlatten(arr) {
  return flatten(           // return shalowly flattened array
    arr.map(x=>             // with each x in array
      Array.isArray(x)      // is x an array?
        ? deepFlatten(x)    // if yes, return deeply flattened x
        : x                 // if no, return just x
    )
  )
}

See demo on JSBin.

References for ECMAScript 6 elements used in this answer:

• Spread operator
• Arrow functions

---

Side note: methods like find() and arrow functions are not supported by all browsers, but it doesn't mean that you can't use these features right now. Just use Babel — it transforms ES6 code into ES5.

Contraception

Because almost all the replies here misuse apply in this way, I removed my comments from yours. I still think using apply/spread this way is bad advise, but since no one cares... – Carolus

@LUH3417 It's not like that, I really appreciate your comments. It turned out you're right -- this solution indeed doesn't work with large arrays. I posted another answer which works fine even with arrays of 200 000 elements. – Pak

If you are using ES6, you can reducer further to: const flatten = arr => [].concat(...arr) – Abrasive

What do you mean "does not work with large arrays"? How large? What happens? – Matchboard

@Matchboard For example trying to flatten a 500000-element array using this method gives "RangeError: Maximum call stack size exceeded". – Pak

Answer 8

You can use Underscore:

var x = [[1], [2], [3, 4]];

_.flatten(x); // => [1, 2, 3, 4]

Portecochere

1+ - You can also specify that you want a shallow flattened array by specifying true for the second argument. – Mattiematting

Answer 9

Generic procedures mean we don't have to rewrite complexity each time we need to utilize a specific behaviour.

concatMap (or flatMap) is exactly what we need in this situation.

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.map(f).reduce(concat, [])

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)

// your sample data
const data =
  [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]

console.log (flatten (data))

foresight

And yes, you guessed it correctly, it only flattens one level, which is exactly how it should work

Imagine some data set like this

// Player :: (String, Number) -> Player
const Player = (name,number) =>
  [ name, number ]

// team :: ( . Player) -> Team
const Team = (...players) =>
  players

// Game :: (Team, Team) -> Game
const Game = (teamA, teamB) =>
  [ teamA, teamB ]

// sample data
const teamA =
  Team (Player ('bob', 5), Player ('alice', 6))

const teamB =
  Team (Player ('ricky', 4), Player ('julian', 2))

const game =
  Game (teamA, teamB)

console.log (game)
// [ [ [ 'bob', 5 ], [ 'alice', 6 ] ],
//   [ [ 'ricky', 4 ], [ 'julian', 2 ] ] ]

Ok, now say we want to print a roster that shows all the players that will be participating in game …

const gamePlayers = game =>
  flatten (game)

gamePlayers (game)
// => [ [ 'bob', 5 ], [ 'alice', 6 ], [ 'ricky', 4 ], [ 'julian', 2 ] ]

If our flatten procedure flattened nested arrays too, we'd end up with this garbage result …

const gamePlayers = game =>
  badGenericFlatten(game)

gamePlayers (game)
// => [ 'bob', 5, 'alice', 6, 'ricky', 4, 'julian', 2 ]

---

rollin' deep, baby

That's not to say sometimes you don't want to flatten nested arrays, too – only that shouldn't be the default behaviour.

We can make a deepFlatten procedure with ease …

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.map(f).reduce(concat, [])

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)

// deepFlatten :: [[a]] -> [a]
const deepFlatten =
  concatMap (x =>
    Array.isArray (x) ? deepFlatten (x) : x)

// your sample data
const data =
  [0, [1, [2, [3, [4, 5], 6]]], [7, [8]], 9]

console.log (flatten (data))
// [ 0, 1, [ 2, [ 3, [ 4, 5 ], 6 ] ], 7, [ 8 ], 9 ]

console.log (deepFlatten (data))
// [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

There. Now you have a tool for each job – one for squashing one level of nesting, flatten, and one for obliterating all nesting deepFlatten.

Maybe you can call it obliterate or nuke if you don't like the name deepFlatten.

---

Don't iterate twice !

Of course the above implementations are clever and concise, but using a .map followed by a call to .reduce means we're actually doing more iterations than necessary

Using a trusty combinator I'm calling mapReduce helps keep the iterations to a minium; it takes a mapping function m :: a -> b, a reducing function r :: (b,a) ->b and returns a new reducing function - this combinator is at the heart of transducers; if you're interested, I've written other answers about them

// mapReduce = (a -> b, (b,a) -> b, (b,a) -> b)
const mapReduce = (m,r) =>
  (acc,x) => r (acc, m (x))

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.reduce (mapReduce (f, concat), [])

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)
  
// deepFlatten :: [[a]] -> [a]
const deepFlatten =
  concatMap (x =>
    Array.isArray (x) ? deepFlatten (x) : x)

// your sample data
const data =
  [ [ [ 1, 2 ],
      [ 3, 4 ] ],
    [ [ 5, 6 ],
      [ 7, 8 ] ] ]

console.log (flatten (data))
// [ [ 1. 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]

console.log (deepFlatten (data))
// [ 1, 2, 3, 4, 5, 6, 7, 8 ]

Souvaine

Frequently, when I see your replies I want to withdraw mine, because they have become worthless. Great answer! concat itself doesn't blow up the stack, only ... and apply does (along with very large arrays). I didn't see it. I just feel terrible right now. – Carolus

Please note that concat in Javascript has a different meaning than in Haskell. Haskell's concat ([[a]] -> [a]) would be called flatten in Javascript and is implemented as foldr (++) [] (Javascript: foldr(concat) ([]) assuming curried functions). Javascript's concat is a weird append ((++) in Haskell), which can handle both [a] -> [a] -> [a] and a -> [a] -> [a]. – Carolus

I guess a better name were flatMap, because that is exactly what concatMap is: The bind instance of the list monad. concatpMap is implemented as foldr ((++) . f) []. Translated into Javascript: const flatMap = f => foldr(comp(concat) (f)) ([]). This is of course similar to your implementation without comp. – Carolus

what's the complexity of that algorithm? – Gladstone

Answer 10

To flatten an array of single element arrays, you don't need to import a library, a simple loop is both the simplest and most efficient solution :

for (var i = 0; i < a.length; i++) {
  a[i] = a[i][0];
}

To downvoters: please read the question, don't downvote because it doesn't suit your very different problem. This solution is both the fastest and simplest for the asked question.

Xenophobe

It doesn't really matter how cryptic it is. This code "flattens" this ['foo', ['bar']] to ['f', 'bar']. – Tranquilize

Well. Of course. It's an answer to the question. What's not clear in an array of arrays ? This answer doesn't try to answer a more general question which woukd be less efficient... – Lawler

indeed, you're correct. I was focused too much on the other examples - not explicitly on the wording. – Tranquilize

Answer 11

A solution for the more general case, when you may have some non-array elements in your array.

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

Colunga

This approach was very effective in flattening the nested array form of result-sets you get from a JsonPath query. – Caro

This will break if we manually pass in the second argument. For example, try this: flattenArrayOfArrays (arr, 10) or this flattenArrayOfArrays(arr, [1,[3]]); - those second arguments are added to the output. – Houphouetboigny

Answer 12

You can also try the new Array.flat() method. It works in the following manner:

let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]].flat()

console.log(arr);

The flat() method creates a new array with all sub-array elements concatenated into it recursively up to the 1 layer of depth (i.e. arrays inside arrays)

If you want to also flatten out 3 dimensional or even higher dimensional arrays you simply call the flat method multiple times. For example (3 dimensions):

let arr = [1,2,[3,4,[5,6]]].flat().flat().flat();

console.log(arr);

Be careful!

Array.flat() method is relatively new. Older browsers like ie might not have implemented the method. If you want you code to work on all browsers you might have to transpile your JS to an older version. Check for MDN web docs for current browser compatibility.

Nucleolated

to flat higher dimensional arrays you simply can call the flat method with Infinity argument. Like this: arr.flat(Infinity) – Retharethink

Answer 13

Another ECMAScript 6 solution in functional style:

Declare a function:

const flatten = arr => arr.reduce(
  (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);

and use it:

flatten( [1, [2,3], [4,[5,[6]]]] ) // -> [1,2,3,4,5,6]

 const flatten = arr => arr.reduce(
         (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
       );


console.log( flatten([1, [2,3], [4,[5],[6,[7,8,9],10],11],[12],13]) )

Consider also a native function Array.prototype.flat() (proposal for ES6) available in last releases of modern browsers. Thanks to @(Константин Ван) and @(Mark Amery) mentioned it in the comments.

The flat function has one parameter, specifying the expected depth of array nesting, which equals 1 by default.

[1, 2, [3, 4]].flat();                  // -> [1, 2, 3, 4]

[1, 2, [3, 4, [5, 6]]].flat();          // -> [1, 2, 3, 4, [5, 6]]

[1, 2, [3, 4, [5, 6]]].flat(2);         // -> [1, 2, 3, 4, 5, 6]

[1, 2, [3, 4, [5, 6]]].flat(Infinity);  // -> [1, 2, 3, 4, 5, 6]

let arr = [1, 2, [3, 4]];

console.log( arr.flat() );

arr =  [1, 2, [3, 4, [5, 6]]];

console.log( arr.flat() );
console.log( arr.flat(1) );
console.log( arr.flat(2) );
console.log( arr.flat(Infinity) );

Spue

This is nice and neat but I think you have done an ES6 overdose. There is no need for the outer function to be an arrow-function. I would stick with the arrow-function for the reduce callback but flatten itself ought to be a normal function. – Williford

@StephenSimpson but is there a need for the outer function to be a non-arrow-function ? "flatten itself ought to be a normal function" – by "normal" you mean "non-arrow", but why? Why use an arrow function in the call to reduce then? Can you supply your line of reasoning? – Souvaine

@naomik My reasoning is that it is unnecessary. It's mainly a matter of style; I should have much clearer in my comment. There is no major coding reason to use one or the other. However, the function is easier to see and read as non-arrow. The inner function is useful as an arrow function as it is more compact (and no context created of course). Arrow functions are great for creating compact easy to read function and avoiding this confusion. However, they can actually make it more difficult to read when a non-arrow would suffice. Others may disagree though! – Williford

Getting a RangeError: Maximum call stack size exceeded – Elisa

@Matt, please share the evnironment you use to reproduce the error – Spue

@Spue Sorry I don't have that code anymore. Ended up using the accepted answer after all. [].concat.apply([], arrays); – Elisa

You know what else is ES6? .flat()! – Subtorrid

-1; flat isn't part of ES6. It's not even part of ES9. It's a proposal, not yet part of the ECMAScript spec, and not yet available in all major JavaScript environments. – Haematin

Answer 14

What about using reduce(callback[, initialValue]) method of JavaScript 1.8

list.reduce((p,n) => p.concat(n),[]);

Would do the job.

Maillol

Answer 15

const common = arr.reduce((a, b) => [...a, ...b], [])

Particulate

Answer 16

You can use Array.flat() with Infinity for any depth of nested array.

var arr = [ [1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]], [[1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]]] ];

let flatten = arr.flat(Infinity)

console.log(flatten)

check here for browser compatibility

Tingey

Answer 17

ES6 One Line Flatten

See lodash flatten, underscore flatten (shallow true)

function flatten(arr) {
  return arr.reduce((acc, e) => acc.concat(e), []);
}

or

function flatten(arr) {
  return [].concat.apply([], arr);
}

Tested with

test('already flatted', () => {
  expect(flatten([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats first level', () => {
  expect(flatten([1, [2, [3, [4]], 5]])).toEqual([1, 2, [3, [4]], 5]);
});

ES6 One Line Deep Flatten

See lodash flattenDeep, underscore flatten

function flattenDeep(arr) {
  return arr.reduce((acc, e) => Array.isArray(e) ? acc.concat(flattenDeep(e)) : acc.concat(e), []);
}

Tested with

test('already flatted', () => {
  expect(flattenDeep([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats', () => {
  expect(flattenDeep([1, [2, [3, [4]], 5]])).toEqual([1, 2, 3, 4, 5]);
});

Luminiferous

Your 2nd example is better written as Array.prototype.concat.apply([], arr) because you create an extra array just to get to the concat function. Runtimes may or may not optimize it away when they run it, but accessing the function on the prototype doesn't look any uglier than this already is in any case. – Wolgast

Answer 18

Using the spread operator:

const input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];
const output = [].concat(...input);
console.log(output); // --> ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

Lucic

Answer 19

Please note: When Function.prototype.apply ([].concat.apply([], arrays)) or the spread operator ([].concat(...arrays)) is used in order to flatten an array, both can cause stack overflows for large arrays, because every argument of a function is stored on the stack.

Here is a stack-safe implementation in functional style that weighs up the most important requirements against one another:

• reusability
• readability
• conciseness
• performance

// small, reusable auxiliary functions:

const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); // aka reduce

const uncurry = f => (a, b) => f(a) (b);

const concat = xs => y => xs.concat(y);


// the actual function to flatten an array - a self-explanatory one-line:

const flatten = xs => foldl(concat) ([]) (xs);

// arbitrary array sizes (until the heap blows up :D)

const xs = [[1,2,3],[4,5,6],[7,8,9]];

console.log(flatten(xs));


// Deriving a recursive solution for deeply nested arrays is trivially now


// yet more small, reusable auxiliary functions:

const map = f => xs => xs.map(apply(f));

const apply = f => a => f(a);

const isArray = Array.isArray;


// the derived recursive function:

const flattenr = xs => flatten(map(x => isArray(x) ? flattenr(x) : x) (xs));

const ys = [1,[2,[3,[4,[5],6,],7],8],9];

console.log(flattenr(ys));

As soon as you get used to small arrow functions in curried form, function composition and higher order functions, this code reads like prose. Programming then merely consists of putting together small building blocks that always work as expected, because they don't contain any side effects.

Carolus

Haha. Totally respect your answer, although reading functional programming like this is still like reading Japanese character by character to me (English speaker). – Orland

If you find yourself implementing features of language A in language B not as a part of project with the sole goal of doing exactly this then someone somewhere had taken a wrong turn. Could it be you? Just going with const flatten = (arr) => arr.reduce((a, b) => a.concat(b), []); saves you visual garbage and explanation to your teammates why you need 3 extra functions and some function calls too. – Hayse

@Hayse But if you write it as separate functions, you will probably be able to reuse them in other code. – Pak

@MichałPerłakowski If you need to use them in several places then don't reinvent the wheel and choose a package from these - documented and supported by other people. – Hayse

Awkward and slow. – Frau

Answer 20

I recommend a space-efficient generator function:

function* flatten(arr) {
  if (!Array.isArray(arr)) yield arr;
  else for (let el of arr) yield* flatten(el);
}

// Example:
console.log(...flatten([1,[2,[3,[4]]]])); // 1 2 3 4

If desired, create an array of flattened values as follows:

let flattened = [...flatten([1,[2,[3,[4]]]])]; // [1, 2, 3, 4]

Add

I like this approach. Similar to https://mcmap.net/q/36813/-merge-flatten-an-array-of-arrays , but uses the spread operator ... to iterate through the generator. – Sympathetic

Answer 21

If you only have arrays with 1 string element:

[["$6"], ["$12"], ["$25"], ["$25"]].join(',').split(',');

will do the job. Bt that specifically matches your code example.

Ensor

Whoever down voted, please explain why. I was searching for a decent solution and of all the solutions I liked this one the most. – Mai

@Mai I didn't downvote it since it technically meets the requirements of the question, but it's likely because this is a pretty poor solution that isn't useful in the general case. Considering how many better solutions there are here, I'd never recommend someone go with this one as it breaks the moment you have more than one element, or when they're not strings. – Firstly

It doesn't handle just arrays with 1 string elements, it also handles this array ['$4', ["$6"], ["$12"], ["$25"], ["$25", "$33", ['$45']]].join(',').split(',') – Devoir

I discovered this method on my own, however knew it must have already been documented somewhere, my search ended here. The drawback with this solution is, it coerces numbers, booleans etc to strings, try [1,4, [45, 't', ['e3', 6]]].toString().split(',') ---- or ----- [1,4, [45, 't', ['e3', 6], false]].toString().split(',') – Chatelaine

Answer 22

I have done it using recursion and closures

function flatten(arr) {

  var temp = [];

  function recursiveFlatten(arr) { 
    for(var i = 0; i < arr.length; i++) {
      if(Array.isArray(arr[i])) {
        recursiveFlatten(arr[i]);
      } else {
        temp.push(arr[i]);
      }
    }
  }
  recursiveFlatten(arr);
  return temp;
}

Haff

Simple and sweet, this answer works better than the accepted answer. It flattens deeply nested levels to, not just the first level – Houphouetboigny

AFAIK that is lexical scoping and not a closure – Strage

@Strage is correct - the difference is that if it was a closure you would return the inner function to the outside and when the outer function is finished you can still use the inner function to access its scope. Here the lifetime of the outer function is longer than that of the inner function so a "closure" is never created. – Wolgast

Answer 23

A Haskellesque approach

function flatArray([x,...xs]){
  return x ? [...Array.isArray(x) ? flatArray(x) : [x], ...flatArray(xs)] : [];
}

var na = [[1,2],[3,[4,5]],[6,7,[[[8],9]]],10];
    fa = flatArray(na);
console.log(fa);

Uncouple

Answer 24

if you use lodash, you can just use its flatten method: https://lodash.com/docs/4.17.14#flatten

The nice thing about lodash is that it also has methods to flatten the arrays:

i) recursively: https://lodash.com/docs/4.17.14#flattenDeep

ii) upto n levels of nesting: https://lodash.com/docs/4.17.14#flattenDepth

For example

const _ = require("lodash");
const pancake =  _.flatten(array)

Quiver

Answer 25

ES6 way:

const flatten = arr => arr.reduce((acc, next) => acc.concat(Array.isArray(next) ? flatten(next) : next), [])

const a = [1, [2, [3, [4, [5]]]]]
console.log(flatten(a))

ES5 way for flatten function with ES3 fallback for N-times nested arrays:

var flatten = (function() {
  if (!!Array.prototype.reduce && !!Array.isArray) {
    return function(array) {
      return array.reduce(function(prev, next) {
        return prev.concat(Array.isArray(next) ? flatten(next) : next);
      }, []);
    };
  } else {
    return function(array) {
      var arr = [];
      var i = 0;
      var len = array.length;
      var target;

      for (; i < len; i++) {
        target = array[i];
        arr = arr.concat(
          (Object.prototype.toString.call(target) === '[object Array]') ? flatten(target) : target
        );
      }

      return arr;
    };
  }
}());

var a = [1, [2, [3, [4, [5]]]]];
console.log(flatten(a));

Tripping

Answer 26

I was goofing with ES6 Generators the other day and wrote this gist. Which contains...

function flatten(arrayOfArrays=[]){
  function* flatgen() {
    for( let item of arrayOfArrays ) {
      if ( Array.isArray( item )) {
        yield* flatten(item)
      } else {
        yield item
      }
    }
  }

  return [...flatgen()];
}

var flatArray = flatten([[1, [4]],[2],[3]]);
console.log(flatArray);

Basically I'm creating a generator that loops over the original input array, if it finds an array it uses the yield* operator in combination with recursion to continually flatten the internal arrays. If the item is not an array it just yields the single item. Then using the ES6 Spread operator (aka splat operator) I flatten out the generator into a new array instance.

I haven't tested the performance of this, but I figure it is a nice simple example of using generators and the yield* operator.

But again, I was just goofing so I'm sure there are more performant ways to do this.

Verney

Answer 27

just the best solution without lodash

let flatten = arr => [].concat.apply([], arr.map(item => Array.isArray(item) ? flatten(item) : item))

Abey

Answer 28

I would rather transform the whole array, as-is, to a string, but unlike other answers, would do that using JSON.stringify and not use the toString() method, which produce an unwanted result.

With that JSON.stringify output, all that's left is to remove all brackets, wrap the result with start & ending brackets yet again, and serve the result with JSON.parse which brings the string back to "life".

• Can handle infinite nested arrays without any speed costs.
• Can rightly handle Array items which are strings containing commas.

var arr = ["abc",[[[6]]],["3,4"],"2"];

var s = "[" + JSON.stringify(arr).replace(/\[|]/g,'') +"]";
var flattened = JSON.parse(s);

console.log(flattened)

• Only for multidimensional Array of Strings/Numbers (not Objects)

Fiora

Your solution is incorrect. It will contain the comma when flattening inner arrays ["345", "2", "3,4", "2"] instead of separating each of those values to separate indices – Stoughton

@realseanp - you misunderstood the value in that Array item. I intentionally put that comma as a value and not as an Array delimiter comma to emphasize the power of my solution above all others, which would output "3,4". – Fiora

I did misunderstand – Stoughton

that seems definitely the fastest solution I've seen for this; are you aware of any pitfalls @Fiora (except the fact it looks a bit hacky of course - treating nested arrays as strings:D) – Gladstone

@GeorgeKatsanos - This method will not work for array items (and nested items) which are not of Primitive value, for example an item which points to a DOM element – Fiora

@Fiora - I got it. – Ctenophore

Answer 29

Ways for making flatten array

• using Es6 flat()
• using Es6 reduce()
• using recursion
• using string manipulation

[1,[2,[3,[4,[5,[6,7],8],9],10]]] - [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// using Es6 flat() 
let arr = [1,[2,[3,[4,[5,[6,7],8],9],10]]]
console.log(arr.flat(Infinity))

// using Es6 reduce()
let flatIt = (array) => array.reduce(
  (x, y) => x.concat(Array.isArray(y) ? flatIt(y) : y), []
)
console.log(flatIt(arr))

// using recursion
function myFlat(array) {
  let flat = [].concat(...array);
  return flat.some(Array.isArray) ? myFlat(flat) : flat;
}
console.log(myFlat(arr));

// using string manipulation
let strArr = arr.toString().split(','); 
for(let i=0;i<strArr.length;i++)
  strArr[i]=parseInt(strArr[i]);

console.log(strArr)

Alliteration

Which is the fastest? – Mauriac

@Mauriac thanks for questioning, I think simple loop is faster. – Alliteration

Answer 30

I think array.flat(Infinity) is a perfect solution. But flat function is a relatively new function and may not run in older versions of browsers. We can use recursive function for solving this.

const arr = ["A", ["B", [["B11", "B12", ["B131", "B132"]], "B2"]], "C", ["D", "E", "F", ["G", "H", "I"]]]
const flatArray = (arr) => {
    const res = []
    for (const item of arr) {
        if (Array.isArray(item)) {
            const subRes = flatArray(item)
            res.push(...subRes)
        } else {
            res.push(item)
        }
    }

    return res
}

console.log(flatArray(arr))

Cortney

Thanks just now an interviewer asked me the same question. – Hulen

Answer 31

You can use "join()" and "split()":

let arrs = [
  ["$6"],
  ["$12"],
  ["$25"],
  ["$25"],
  ["$18"],
  ["$22"],
  ["$10"]
];

let newArr = arrs.join(",").split(",");

console.log(newArr); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

In addition, you can use "toString()" and "split()" as well:

let arrs = [
  ["$6"],
  ["$12"],
  ["$25"],
  ["$25"],
  ["$18"],
  ["$22"],
  ["$10"]
];

let newArr = arrs.toString().split(",");

console.log(newArr); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

However, both two ways above don't work properly if string contains commas:

"join()" and "split()":

let arrs = [
  ["$,6"],
  ["$,12"],
  ["$2,5"],
  ["$2,5"],
  [",$18"],
  ["$22,"],
  ["$,1,0"]
];

let newArr = arrs.join(",").split(",");

console.log(newArr); 
// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]

"toString()" and "split()":

let arrs = [
  ["$,6"],
  ["$,12"],
  ["$2,5"],
  ["$2,5"],
  [",$18"],
  ["$22,"],
  ["$,1,0"]
];

let newArr = arrs.toString().split(",");

console.log(newArr); 
// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]

Cartridge

This is an extremely problematic and error prone way to do this. – Footsore

@Brad. But it's fast if you're sure your array won't contain commas – Philina

Answer 32

That's not hard, just iterate over the arrays and merge them:

var result = [], input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"]];

for (var i = 0; i < input.length; ++i) {
    result = result.concat(input[i]);
}

Atombomb

Answer 33

Here is the recursive way...

function flatten(arr){
    let newArray = [];
    for(let i=0; i< arr.length; i++){
        if(Array.isArray(arr[i])){
          newArray =  newArray.concat(flatten(arr[i]))
        }else{
          newArray.push(arr[i])
        }
    }
  return newArray; 
}

console.log(flatten([1, 2, 3, [4, 5] ])); // [1, 2, 3, 4, 5]
console.log(flatten([[[[1], [[[2]]], [[[[[[[3]]]]]]]]]]))  // [1,2,3]
console.log(flatten([[1],[2],[3]])) // [1,2,3]

Sinful

Answer 34

function flatten(input) {
  let result = [];
  
  function extractArrayElements(input) {
    for(let i = 0; i < input.length; i++){
      if(Array.isArray(input[i])){
        extractArrayElements(input[i]);
      }else{
        result.push(input[i]);
      }
    }
  }
  
  extractArrayElements(input);
  
  return result;
}


// let input = [1,2,3,[4,5,[44,7,8,9]]];
// console.log(flatten(input));

// output [1,2,3,4,5,6,7,8,9]

Neology

Answer 35

Here is the fastest solution in Typescript, which works also on arrays with multiple levels of nesting:

export function flatten<T>(input: Array<any>, output: Array<T> = []): Array<T> {
    for (const value of input) {
        Array.isArray(value) ? flatten(value, output) : output.push(value);
    }
    return output;
}

and than:

const result = flatten<MyModel>(await Promise.all(promises));

Stenography

Answer 36

const arr = [1, 2, [3, 4]];

arr.reduce((acc, val) => acc.concat(val), []);

Mesquite

Answer 37

Well if your coding environment supports ES6 (ES2015), you need not write any recursive functions or use array methods like map, reduce etc.

A simple spread operator (...) will help you flatten an Array of arrays into a single Array

eg:

  const data = [[1, 2, 3], [4, 5],[2]]
  let res = []
  data.forEach(curSet=>{
      res = [...res,...curSet]
  })
  console.log(res) //[1, 2, 3, 4, 5, 2]

Pablo

Answer 38

I am using this method to flat mixed arrays: (which seems easiest for me). Wrote it in longer version to explain steps.

function flattenArray(deepArray) {
    // check if Array
    if(!Array.isArray(deepArray)) throw new Error('Given data is not an Array')

    const flatArray = deepArray.flat() // flatten array
    const filteredArray = flatArray.filter(item => !!item) // filter by Boolean
    const uniqueArray = new Set(filteredArray) // filter by unique values
    
    return [...uniqueArray] // convert Set into Array
}

// shorter version:

const flattenArray = (deepArray) => [...new Set(deepArray.flat().filter(item=>!!item))]

flattenArray([4,'a', 'b', [3, 2, undefined, 1], [1, 4, null, 5]])) // 4,'a','b',3,2,1,5

Codesandbox link

Modern method

Use of [].flat(Infinity) method

const nestedArray = [1,[2,[3],[4,[5,[6,[7]]]]]]
const flatArray = nestedArray.flat(Infinity)
console.log(flatArray)

Burkhard

Answer 39

It looks like this looks like a job for RECURSION!

• Handles multiple levels of nesting
• Handles empty arrays and non array parameters
• Has no mutation
• Doesn't rely on modern browser features

Code:

var flatten = function(toFlatten) {
  var isArray = Object.prototype.toString.call(toFlatten) === '[object Array]';

  if (isArray && toFlatten.length > 0) {
    var head = toFlatten[0];
    var tail = toFlatten.slice(1);

    return flatten(head).concat(flatten(tail));
  } else {
    return [].concat(toFlatten);
  }
};

Usage:

flatten([1,[2,3],4,[[5,6],7]]);
// Result: [1, 2, 3, 4, 5, 6, 7] 

Foredo

careful, flatten(new Array(15000).fill([1])) throws Uncaught RangeError: Maximum call stack size exceeded and freezed my devTools for 10 seconds – Flexible

@pietrovismara, my test is around 1s. – Logicize

Answer 40

I propose two short solutions without recursion. They are not optimal from a computational complexity point of view, but work fine in average cases:

let a = [1, [2, 3], [[4], 5, 6], 7, 8, [9, [[10]]]];

// Solution #1
while (a.find(x => Array.isArray(x)))
    a = a.reduce((x, y) => x.concat(y), []);

// Solution #2
let i = a.findIndex(x => Array.isArray(x));
while (i > -1)
{
    a.splice(i, 1, ...a[i]);
    i = a.findIndex(x => Array.isArray(x));
}

Paul

Answer 41

The logic here is to convert input array to string and remove all brackets([]) and parse output to array. I'm using ES6 template feature for this.

var x=[1, 2, [3, 4, [5, 6,[7], 9],12, [12, 14]]];

var y=JSON.parse(`[${JSON.stringify(x).replace(/\[|]/g,'')}]`);

console.log(y)

Leuctra

this is the fastest and cleverest way to do it. I was using this to avoid recursion and easily rebuild the array, but yours is 3% faster. Way to go :) const flatten = function (A) { return A .toString() .split(',') .reduce( (a,c) => { let i = parseFloat(c); c = (!Number.isNaN(i)) ? i : c; a.push(c); return a; }, []); – Presidentship

Answer 42

Here is a version in Typescript based on the answer by artif3x, with a bonus implementation of flatMap for Scala fans.

function flatten<T>(items: T[][]): T[] {
  return items.reduce((prev, next) => prev.concat(next), []);
}

function flatMap<T, U>(items: T[], f: (t: T) => U[]): U[] {
  return items.reduce((prev, next) => prev.concat(f(next)), new Array<U>());
}

Salpa

Answer 43

Here's another deep flatten for modern browsers:

function flatten(xs) {
  xs = Array.prototype.concat.apply([], xs);
  return xs.some(Array.isArray) ? flatten(xs) : xs;
};

Levileviable

dumping code is not an answer..please explain the steps of this solution. it seems like a very elegant one, but also, complex. – Fiora

Answer 44

Nowadays the best and easy way to do this is joining and spliting the array like this.

var multipleArrays = [["$6","$Demo"], ["$12",["Multi","Deep"]], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]]

var flattened = multipleArrays.join().split(",")

This solution works with multiple levels and is also oneliner.

DEMO

EDIT for ECMAScript 6

Since ECMAScript 6 has been standardized, you can change the operation [].concat.apply([], arrays); for [].concat(...arrays);

var flattened = [].concat(...input);

DEMO

EDIT Most Efficient solution

The most efficient way to solve the problem is using a loop. You can compare the "ops/sec" velocity here

var flattened=[];
for (var i=0; i<input.length; ++i) {
    var current = input[i];
    for (var j=0; j<current.length; ++j)
        flattened.push(current[j]);
} 

DEMO

Hope It Helps

Destalinization

It doesn't work when array contains strings which contain commas, for example: [[","]].join().split(",") doesn't give desired result. – Pak

Answer 45

const flatten = array => array.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []); 

Per request, Breaking down the one line is basically having this.

function flatten(array) {
  // reduce traverses the array and we return the result
  return array.reduce(function(acc, b) {
     // if is an array we use recursion to perform the same operations over the array we found 
     // else we just concat the element to the accumulator
     return acc.concat( Array.isArray(b) ? flatten(b) : b);
  }, []); // we initialize the accumulator on an empty array to collect all the elements
}

Battologize

From review queue: May I request you to please add some more context around your answer. Code-only answers are difficult to understand. It will help the asker and future readers both if you can add more information in your post. – Diplo

Your code is written in cutting-edge, shortest way but honestly It takes me more time to figure out what it is actually doing... not good for maintenance – Gastrointestinal

Nice one! You can flatten array like objects too if you change Array.isArray(b) in to b.length and add a Array.from(array) after the return instead of array. – Fingered

Answer 46

Just to add to the great solutions. I used recursion to solve this.

            const flattenArray = () => {
                let result = [];
                return function flatten(arr) {
                    for (let i = 0; i < arr.length; i++) {
                        if (!Array.isArray(arr[i])) {
                            result.push(arr[i]);
                        } else {
                            flatten(arr[i])
                        }
                    }
                    return result;
                }
            }

Test results: https://codepen.io/ashermike/pen/mKZrWK

Obstetric

Answer 47

It's better to do it in a recursive way, so if still another array inside the other array, can be filtered easily...

const flattenArray = arr =>
  arr.reduce(
    (res, cur) =>
       !Array.isArray(cur) 
       ? res.concat(cur)
       : res.concat(flattenArray(cur)), []);

And you can call it like:

flattenArray([[["Alireza"], "Dezfoolian"], ["is a"], ["developer"], [[1, [2, 3], ["!"]]]);

and the result isas below:

["Alireza", "Dezfoolian", "is a", "developer", 1, 2, 3, "!"]

Regeniaregensburg

This answer needs to be shown in a simpler fashion as a function. It's very hard to read and understand. – Ramsgate

Answer 48

Simply using spread operator we can flatten in the following way.

var OriginalArray = [[5, 1], [6], [2], [8]];
var newArray = [];

for (let i = 0; i < OriginalArray.length; i++) {
  newArray.push(...OriginalArray[i]);
}

console.log(newArray)

Erection

Answer 49

I have just try to solve the problem without using any inbuild function.

var arr = [1, 3, 4, 65, [3, 5, 6, 9, [354, 5, 43, 54, 54, 6, [232, 323, 323]]]];
var result = [];

function getSingleArray(inArr) {
  for (var i = 0; i < inArr.length; i++) {
    if (typeof inArr[i] == "object") {
      getSingleArray(inArr[i]); // Calling Recursively
    } else {
      result.push(inArr[i]);
    }
  }
}

getSingleArray(arr);
console.log(result); // [1, 3, 4, 65, 3, 5, 6, 9, 354, 5, 43, 54, 54, 6, 232, 323, 323]

Peculate

Answer 50

Here is the solution non recursive flatten deep using a stack.

    function flatten(input) {
        const stack = [...input];
        const res = [];
        while (stack.length) {
            const next = stack.pop();
            if (Array.isArray(next)) {
                stack.push(...next);
            } else {
                res.push(next);
            }
        }
        return res.reverse();
    }
    const arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];
    flatten(arrays);

Hortense

Answer 51

[1,[2,3],[4,[5,6]]].reduce(function(p, c) {
    return p.concat(c instanceof Array ? 
                    c.reduce(arguments.callee, []) : 
                    [c]); 
}, []);

Beira

Answer 52

if your array only consists out of integers or strings you can use this dirty hack:

var arr = [345,2,[34],2,[524,[5456]],[5456]];
var flat = arr.toString().split(',');

Works, in FF, IE and Chrome didn't test the other browsers yet.

Oscan

Just wondering why this is a hack? I think it is a smart and simple way to do it. – Eld

IMO it's a hack because it abuses the .toString() function (.toString will call for me .toString recursively) which if I recall correctly returned previously "[object Array]" instead of a recursive arr.join(',') :) – Oscan

Thanks for the explanation. I have just experienced that yesterday. =) – Eld

@TimHong haha I hope nothing broke – Oscan

Hahaha. It was all good. I tested it before checking in anything. In the end, I wrote my own version of it. =) I pasted my answer here. (Should be on top now, since it is the newest answer.) Yeah, thanks for asking. Hahaha. – Eld

What will happen if the value contains a 'COMMA' ?? – Ecuador

just like you expect, if arr is [[1,2],["3,4"]] it'll end up with: ["1","2","3", "4"] – Oscan

@Oscan - but that isn't what you would expect, which should be ["1","2","3,4"] – Fiora

Needless to say, numbers are converted to strings with this solution. But it also fails with empty arrays: [1,[2,3], [], 4, [5]].toString().split(','); will output ["1", "2", "3", "", "4", "5"]. Assuming we are interested in numbers, one alternative would be: [1,[2,3], [], 4, [5]].toString().split(',').filter((e) => e !== '').map(Number);. – Canada

Answer 53

To flatten a two-dimensional array in one line:

[[1, 2], [3, 4, 5]].reduce(Function.prototype.apply.bind(Array.prototype.concat))
// => [ 1, 2, 3, 4, 5 ]

Yoicks

That's pretty brilliant. It does fail at a certain nesting depth: [[1, 2], [3, 4, 5], [6, [[7]]]]. – Sacrificial

Nice hack! You can shorten your code if you use the following auxiliary functions: const bindable = Function.bind.bind(Function.bind); const applicable = bindable(Function.apply); and then [[1, 2], [3, 4, 5]].reduce(applicable([].concat));. – Carolus

Answer 54

There's a much faster way of doing this than using the merge.concat.apply() method listed in the top answer, and by faster I mean more than several orders of magnitude faster. This assumes your environment has access to the ES5 Array methods.

var array2d = [
  ["foo", "bar"],
  ["baz", "biz"]
];
merged = array2d.reduce(function(prev, next) {
    return prev.concat(next);
});

Here's the jsperf link: http://jsperf.com/2-dimensional-array-merge

Warnke

I don’t know what’s wrong with the JSPerf because the link is dead, but this is backwards. Repeated concat is not only slower, it’s asymptotically slower. – Frau

Answer 55

I'm aware that this is hacky, but the must succinct way I know of to flatten an array(of any depth!) of strings(without commas!) is to turn the array into a string and then split the string on commas:

var myArray =[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
var myFlatArray = myArray.toString().split(',');

myFlatArray;
// ["$6", "$12", "$25", "$25", "$18", "$22", "$10", "$0", "$15", "$3", "$75", "$5", "$100", "$7", "$3", "$75", "$5"]

This should work on any depth of nested arrays containing only strings and numbers(integers and floating points) with the caveat that numbers will be converted to strings in the process. This can be solved with a little mapping:

var myArray =[[[1,2],[3,4]],[[5,6],[7,8]],[[9,0]]];
var myFlatArray = myArray.toString().split(',').map(function(e) { return parseInt(e); });
myFlatArray;
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Stormproof

Doesn't quite work. See my comments on previous answer: https://mcmap.net/q/36813/-merge-flatten-an-array-of-arrays – Canada

Answer 56

Recursive version that works on all datatypes

 /*jshint esversion: 6 */

// nested array for testing
let nestedArray = ["firstlevel", 32, "alsofirst", ["secondlevel", 456,"thirdlevel", ["theinnerinner", 345, {firstName: "Donald", lastName: "Duck"}, "lastinner"]]];

// wrapper function to protect inner variable tempArray from global scope;
function flattenArray(arr) {

  let tempArray = [];

  function flatten(arr) {
    arr.forEach(function(element) {
      Array.isArray(element) ? flatten(element) : tempArray.push(element);     // ternary check that calls flatten() again if element is an array, hereby making flatten() recursive.
    });
  }

  // calling the inner flatten function, and then returning the temporary array
  flatten(arr);
  return tempArray;
}

// example usage:
let flatArray = flattenArray(nestedArray);

Internee

Answer 57

/**
* flatten an array first level
* @method flatten
* @param array {Array}
* @return {Array} flatten array
*/
function flatten(array) {
  return array.reduce((acc, current) => acc.concat(current), []);
}


/**
* flatten an array recursively
* @method flattenDeep
* @param array {Array}
* @return {Array} flatten array
*/
function flattenDeep(array) {
  return array.reduce((acc, current) => {
    return Array.isArray(current) ? acc.concat(flattenDeep(current)) : acc.concat([current]);
  }, []);
}

/**
* flatten an array recursively limited by depth
* @method flattenDepth
* @param array {Array}
* @return {Array} flatten array
*/
function flattenDepth(array, depth) {
  if (depth === 0) {
    return array;
  }
  return array.reduce((acc, current) => {
    return Array.isArray(current) ? acc.concat(flattenDepth(current, --depth)) : acc.concat([current]);
  }, []);
}

Battologize

Why do you even have a ternary operator, if the values on left and right are doing the same thing in first solution: return Array.isArray(current) ? acc.concat(current) : acc.concat([current]);? Why even check for if the item is also an array, if it's just one level :) – Houphouetboigny

I mean: [1,2].concat(3) is same as [1,2].concat([3]) – Houphouetboigny

Answer 58

The following code will flatten deeply nested arrays:

/**
 * [Function to flatten deeply nested array]
 * @param  {[type]} arr          [The array to be flattened]
 * @param  {[type]} flattenedArr [The flattened array]
 * @return {[type]}              [The flattened array]
 */
function flattenDeepArray(arr, flattenedArr) {
  let length = arr.length;

  for(let i = 0; i < length; i++) {
    if(Array.isArray(arr[i])) {
      flattenDeepArray(arr[i], flattenedArr);
    } else {
      flattenedArr.push(arr[i]);
    }
  }

  return flattenedArr;
}

let arr = [1, 2, [3, 4, 5], [6, 7]];

console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4, 5 ], [ 6, 7 ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7 ]

arr = [1, 2, [3, 4], [5, 6, [7, 8, [9, 10]]]];

console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4 ], [ 5, 6, [ 7, 8, [Object] ] ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

Chokedamp

Answer 59

You can just keep on using Array.flat() method to achieve this even when array is a lot more nested.

[1,2,3,[2]].flat() 

is equivalent to

[1,2,3,[2]].flat(1)

so as your nesting increases you can keep on increasing number.

eg:

[1,[2,[3,[4]]]].flat(3) // [1, 2, 3, 4]

And if you are not sure about level of nesting you can just pass Infinity as parameter

[1,2,3,[2,[3,[3,[34],43],[34]]]].flat(Infinity) //[1, 2, 3, 2, 3, 3, 34, 43, 34]

Monopetalous

This doesn't work if the array contains a string which contains a comma. For example, [['test,test'], ['test']].join().split(',') gives ['test', 'test', 'test'] instead of ['test,test', 'test']. – Pak

I understand it but comma is just an separator. if you want you can use any other which is for sure not be part of json. or you can use combination of special characters as separator. that's logical right. any ways thanks for down voting @MichałPerłakowski – Monopetalous

I normally use some jibberish, a pattern that is impossible in the dataset. – Mong

@MichałPerłakowski I hope this fits better for all Array type. I found it on twitter and looks worth updating here. – Monopetalous

Answer 60

You can use Ramda JS flatten

var arr = [[1,2], [3], [4,5]];
var flattenedArray = R.flatten(arr); 

console.log(flattenedArray)

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.js"></script>

Africanist

Answer 61

let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
arr = arr.reduce((a, b) => a.concat(b)); // flattened

Shadow

Answer 62

Simple flatten util i've written

const flatten = (arr, result = []) => {
    if (!Array.isArray(arr)){
        return [...result, arr];
    }
     arr.forEach((a) => {
         result = flatten(a, result)
    })

    return result
}

console.log(flatten([1,[2,3], [4,[5,6,[7,8]]]])) // [ 1, 2, 3, 4, 5, 6, 7, 8 ]

Curren

Answer 63

Define an array of arrays in javascript called foo and flatten that array of arrays into a single array using javascript's array concat builtin method:

const foo = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]] 
console.log({foo}); 

const bar = [].concat(...foo) 
console.log({bar});

Should print:

{ foo: 
   [ [ '$6' ],
     [ '$12' ],
     [ '$25' ],
     [ '$25' ],
     [ '$18' ],
     [ '$22' ],
     [ '$10' ] ] }
{ bar: [ '$6', '$12', '$25', '$25', '$18', '$22', '$10' ] }

Renaterenato

Answer 64

Since ES2019 has introduced flat and flatMap then flat any array can be done like this:

const myArr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
const myArrFlat= myArr.flat(Infinity);
console.log(myArrFlat); // ["$6", "$12", "$25", ...]

Ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat

Donnenfeld

Answer 65

Recursively calling the deepFlatten function so we can spread the inner array without using any external helper method is the way to go.

const innerArr = ['a', 'b'];
const multiDimArr = [[1, 2], 3, 4, [5, 6, innerArr], 9];

const deepFlatten = (arr) => {
  const flatList = [];
  arr.forEach(item => {
    Array.isArray(item)
     ? flatList.push(...deepFlatten(item)) // recursive call
     : flatList.push(item)
  });
  return flatList;
}

Limann

Answer 66

This solution will work for any depth level (specifying how deep a nested array structure should be) of array.

function flatten(obj) {
    var out = [];
    function cleanElements(input) {
        for (var i  in input){
            if (input[i]instanceof Array){
                cleanElements(input[i]);
            }
            else {
                out.push(input[i]);
            }
        }
    }
    cleanElements(obj);
    return (out);
}

Radiosonde

Answer 67

Use this method to flat two arrays

arr1.concat(...arr2);

Fipple

Answer 68

Here is my version of it. It allows you to flatten a complicated object which could be used in more scenarios:

Input

var input = {
   a: 'asdf',
   b: [1,2,3],
   c: [[1,2],[3,4]],
   d: {subA: [1,2]}
}

Code

The function is like this:

function flatten (input, output) {

  if (isArray(input)) {
    for(var index = 0, length = input.length; index < length; index++){
      flatten(input[index], output);
    }
  }
  else if (isObject(input)) {
    for(var item in input){
      if(input.hasOwnProperty(item)){
        flatten(input[item], output);
      }
    }
  }
  else {
    return output.push(input);
  }
};

function isArray(obj) {
  return Array.isArray(obj) || obj.toString() === '[object Array]';
}

function isObject(obj) {
  return obj === Object(obj);
}

Usage

var output = []

flatten(input, output);

Output

["asdf", 1, 2, 3, 1, 2, 3, 4, 1, 2]

Eld

Answer 69

If you need to support IE8 and, therefore, can't use methods such as reduce or isArray, here is a possible solution. It is a verbose approach to help you to understand the recursive algorithm.

function flattenArray(a){

    var aFinal = [];

    (function recursiveArray(a){

        var i,
            iCount = a.length;

        if (Object.prototype.toString.call(a) === '[object Array]') {
            for (i = 0; i < iCount; i += 1){
                recursiveArray(a[i]);
            }
        } else {
            aFinal.push(a);
        }

    })(a);

    return aFinal;

}

var aMyArray = [6,3,4,[12,14,15,[23,24,25,[34,35],27,28],56],3,4];

var result = flattenArray(aMyArray);

console.log(result);

Nameless

Answer 70

var arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
var merged = [].concat.apply([], arrays);
alert(merged);

Assemblyman

Answer 71

You can flatten an array of arrays using Array.prototype.reduce() and Array.prototype.concat()

var data = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]].reduce(function(a, b) {
  return a.concat(b);
}, []);
console.log(data);

Related docs: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

Batch

Answer 72

I originally thought to use the .reduce method and recursively call a function to flatten inner arrays, however this can lead to stack overflows when you are working with a deeply nested array of deeply nested arrays. Using concat is also not the best way to go, because each iteration will create a new shallow copy of the array. What we can do instead is this:

const flatten = arr => {
    for(let i = 0; i < arr.length;) {
        const val = arr[i];
        if(Array.isArray(val)) {
            arr.splice(i, 1, ...val);
        } else {
            i ++;
        }
    }
    return arr;
}

We are not creating new arrays via concat and we are not recursively calling any functions.

http://jsbin.com/firiru/4/edit?js,console

Stoughton

Answer 73

I have a simple solution without using in a special js function. (like reduce etc)

const input = [[0, 1], [2, 3], [4, 5]]
let flattened=[];

for (let i=0; i<input.length; ++i) {
    let current = input[i];
    for (let j=0; j<current.length; ++j)
        flattened.push(current[j]);
}

Gradate

Answer 74

Yet another approach using jQuery $.map() function. From jQuery documentation:

The function can return an array of values, which will be flattened into the full array.

var source = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];
var target = $.map(source, function(value) { return value; }); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

Quipu

Answer 75

let arr = [1, [2, 3, [4, 5, [6, 7], [8, 9, 10, 11, 12]]]];

function flattenList(nestedArr) {
  let newFlattenList = [];

  const handleFlat = (array) => {
    let count = 0;
    while (count < array.length) {
      let item = array[count];
      if (Array.isArray(item)) {
        handleFlat(item);
      } else {
        newFlattenList.push(item);
      }
      count++;
    }
  };
  handleFlat(nestedArr);
  return newFlattenList;
}`enter code here`

console.log(flattenList(arr));

CodeSandBox Link

Waites

Answer 76

Simple and handles multiple levels of nested:

// deeply nested array
const myArray = [1, 2, [3, 4, [5, 6, [[[7,8, [[[[[9, 10]]]]]]]]]]] ;

const flatten = (arr) => {
    for (let index = 0; index < arr.length; index++) {
        const elem = arr[index];

        if (Array.isArray(elem)) {
            arr.splice(index, 1, ...elem);
            index--;
        }
    }
};

flatten(myArray);
console.log(myArray); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Rosario

Answer 77

let mainArr =[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
let temp = [];

const flattenArray = (arr) =>{
  
  let n = arr.length;

  for(let i=0;i<n;i++){
    if(typeof(arr[i]) == "string" || typeof(arr[i]) == "number"){
      temp.push(arr[i]);
    }
    else if(typeof(arr[i]) == "object"){
      flattenArray(arr[i]);
    }
  }
}

flattenArray(mainArr)
console.log(temp)

Skidway

Answer 78

Flatten polyfill using recursion:

function flatten(arr) {
  let ans = [];
  const convert = (arr) => {
    if (!Array.isArray(arr)) {
      ans.push(arr);

      return;
    }

    arr.forEach((it) => {
      convert(it)
    });
  };

  convert(arr);

  return ans;
}

console.log(flatten([ [ 1, 2 ], [ 3, [ 4 ] ] ]));

Brummell

Answer 79

Array.prototype.flatten = Array.prototype.flatten || function() {
    return [].reduce.call(this, function(flat, toFlatten) {
        return flat.concat(Array.isArray(toFlatten) ? toFlatten.flatten() : toFlatten);
    },[])
};

Pascia

I'm reviewing, can you add some more information around your solution? Why you feel it's efficient? – Harkness

Answer 80

I answer this question just with ES6, assume the deep array is:

const deepArray = ['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];

If you know or guess the depth of your arrays is not more than a number like 7, use below code:

const flatArray = deepArray.flat(7);

But if you don't know the depth of your deep arrays or your JavaScript engine doesn't support flat like react-native JavaScriptCore, use below function that is used JavaScript reduce function:

 const deepFlatten = arr =>
         arr.reduce(
           (acc, val) =>
             Array.isArray(val) 
               ? acc.concat(deepFlatten(val)) 
               : acc.concat(val),
             []
         );

Both of methods return below result:

["1", "a", "b", 2, "4", 3, "c", 5]

Vogue

Answer 81

Much simpler and straight-forward one; with option to deep flatten;

const flatReduce = (arr, deep) => {
    return arr.reduce((acc, cur) => {
        return acc.concat(Array.isArray(cur) && deep ? flatReduce(cur, deep) : cur);
    }, []);
};

console.log(flatReduce([1, 2, [3], [4, [5]]], false)); // =>  1,2,3,4,[5]
console.log(flatReduce([1, 2, [3], [4, [5, [6, 7, 8]]]], true)); // => 1,2,3,4,5,6,7,8

Endocentric

Answer 82

const arr = [1, 2, '22',[1,33,44,['ddd'], 5678], 'abbb', 'ccc', 1234];

const flat = String(arr).split(',').map((elm)=>  {

    return  !isNaN(elm) ? Number(elm) : elm
    
})
console.log(flat)

Stannic

Answer 83

What about deep flatten & Object Oriented ?

[23, [34, 454], 12, 34].flatten();
// -->   [23,34, 454, 12, 34]

---

[23, [34, 454,[66,55]], 12, 34].flatten();

// -->  [23, 34, 454, [66,55], 12, 34]

DEEP Flatten :

[23, [34, 454,[66,55]], 12, 34].flatten(true);

// --> [23, 34, 454, 66, 55, 12, 34]

DEMO

CDN

---

If all array elements are Integer,Float,... or/and String , So just , do this trick :

var myarr=[1,[7,[9.2]],[3],90];
eval('myarr=['+myarr.toString()+']');
print(myarr);
// [1, 7, 9.2, 3, 90]

DEMO

First

The code in the demo doesn't make sense, unless explained. – Houphouetboigny

FYI, extending the native Array's prototype is generally discouraged. – Koger

Answer 84

I believe that the best way to do this would be something like this:

var flatten = function () {
  return [].slice.call(arguments).toString().split(',');
};

Crucifix

Answer 85

I was just looking for the faster and easy solution to do this, why? because I get this as a one interview question and I got curious, so I made this:

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

var i = [[1,2,[3]],4,[2,3,4,[4,[5]]]], output;

// Start timing now
console.time("flatten");
output = new Array(JSON.stringify(i).replace(/[^\w\s,]/g,"")); 
output
// ... and stop.
console.timeEnd("flatten");

// Start timing now
console.time("flatten2");
output = [].concat.apply([], i)
output
// ... and stop.
console.timeEnd("flatten2");

// Start timing now
console.time("flatten3");
output = flattenArrayOfArrays(i)
output
// ... and stop.
console.timeEnd("flatten3");

I used the most popular answers here and my solution. I guess somebody will find this interesting. Cheers!

Irreligious

Answer 86

Sheer Magic of ES6

const flat = A => A.reduce((A, a) => Array.isArray(a) ? [...A, ...flat(a)] : [...A, a], []);

Pharmacognosy

Answer 87

Using code from there.

I would write:

myArray.enumerable().selectMany(function(x) { return x; }).array()

Digestive