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

User · Answer

1  2 3   4  5 6    reduce function p  c        return p concat c instanceof Array                        c reduce arguments callee                              c

User · Answer

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    x000D   x000D  const arr     A     B      B11    B12     B131    B132      B2      C     D    E    F     G    H    I     x000D  const flatArray    arr    gt    x000D      const res      x000D      for  const item of arr    x000D          if  Array isArray item     x000D              const subRes   flatArray item  x000D              res push    subRes  x000D            else   x000D              res push item  x000D            x000D        x000D   x000D      return res x000D    x000D   x000D  console log flatArray arr   x000D   x000D   x000D

User · Answer

You can use Underscore   var x     1    2    3  4       flatten x        gt   1  2  3  4

User · Answer

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

User · Answer

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  lt  input length    i        result   result concat input i

User · Answer

There is 2 way to flat your array  1-First One You Can Use Array prototype flat Method const veryDeep     1   2  2   3   4   5   6       1     veryDeep flat Infinity       1  2  2  3  4  5  6  1        If you don t know the depth of the array   simply pass Infinity      Or You Can Put Argument If You Know How Much Nested Your Array Is const twoLevelsDeep     1   2  2   1      depth   1 twoLevelsDeep flat     1   2  2   1     depth   2 twoLevelsDeep flat 2       1  2  2  1     2-Second Way You Can Flat Your Array By Using Spread Operator In ES6 And Concat It Will Flat Your Array Regardless How Many Nested In It  const multidimension                              concat    multidimension      This will return                         const multidimension    1   2  3  4   5   6  7           concat    multidimension      This will return   1  2  3  4  5  6  7

User · Answer

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

User · Answer

x000D   x000D  var arrays       6       12       25       25       18       22       10       0       15      3       75       5       100       7       3       75       5     x000D  var merged      concat apply     arrays   x000D  alert merged   x000D   x000D   x000D

User · Answer

What about deep flatten  amp  Object Oriented     23   34  454   12  34  flatten       -- gt     23 34  454  12  34       23   34  454  66 55    12  34  flatten        -- gt    23  34  454   66 55   12  34    DEEP Flatten     23   34  454  66 55    12  34  flatten true       -- gt   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

User · Answer

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  lt  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     gt    flattenDeepArray arr             1  2    3  4  5      6  7        gt     1  2  3  4  5  6  7    arr    1  2   3  4    5  6   7  8   9  10       console log arr     gt    flattenDeepArray arr              1   2      3   4         5   6      7   8    Object               gt       1   2   3   4   5   6   7   8   9   10

User · Answer

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    x000D   x000D     small  reusable auxiliary functions  x000D   x000D  const foldl   f   gt  acc   gt  xs   gt  xs reduce uncurry f   acc      aka reduce x000D   x000D  const uncurry   f   gt   a  b    gt  f a   b   x000D   x000D  const concat   xs   gt  y   gt  xs concat y   x000D   x000D   x000D     the actual function to flatten an array - a self-explanatory one-line  x000D   x000D  const flatten   xs   gt  foldl concat        xs   x000D   x000D     arbitrary array sizes  until the heap blows up  D  x000D   x000D  const xs     1 2 3   4 5 6   7 8 9    x000D   x000D  console log flatten xs    x000D   x000D   x000D     Deriving a recursive solution for deeply nested arrays is trivially now x000D   x000D   x000D     yet more small  reusable auxiliary functions  x000D   x000D  const map   f   gt  xs   gt  xs map apply f    x000D   x000D  const apply   f   gt  a   gt  f a   x000D   x000D  const isArray   Array isArray  x000D   x000D   x000D     the derived recursive function  x000D   x000D  const flattenr   xs   gt  flatten map x   gt  isArray x    flattenr x    x   xs    x000D   x000D  const ys    1  2  3  4  5  6   7  8  9   x000D   x000D  console log flattenr ys    x000D   x000D   x000D    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

User · Answer

You can also try the new Array flat   method  It works in the following manner   x000D   x000D  let arr       6       12       25       25       18       22       10    flat    console log arr   x000D   x000D   x000D   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    x000D   x000D  let arr    1 2  3 4  5 6    flat   flat   flat     console log arr   x000D   x000D   x000D   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

User · Answer

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

User · Answer

ES6 One Line Flatten  See lodash flatten  underscore flatten  shallow true   function flatten arr      return arr reduce  acc  e    gt  acc concat e            or  function flatten arr      return    concat apply     arr       Tested with  test  already flatted        gt      expect flatten  1  2  3  4  5    toEqual  1  2  3  4  5         test  flats first level        gt      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    gt  Array isArray e    acc concat flattenDeep e     acc concat e            Tested with  test  already flatted        gt      expect flattenDeep  1  2  3  4  5    toEqual  1  2  3  4  5         test  flats        gt      expect flattenDeep  1   2   3   4    5     toEqual  1  2  3  4  5

User · Answer

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

User · Answer

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  amp  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     x000D   x000D  var arr     abc     6      3 4    2    x000D   x000D  var s         JSON stringify arr  replace       g           x000D  var flattened   JSON parse s   x000D   x000D  console log flattened  x000D   x000D   x000D     Only for multidimensional Array of Strings Numbers  not Objects

User · Answer

What about using reduce callback   initialValue   method of JavaScript 1 8  list reduce  p n    gt  p concat n         Would do the job

User · Answer

For Scala users looking for a way to replicate Seq flatten in Javascript  here is a pimp of Array   Array prototype flatten   function       return    concat apply     this        which can be used this way     12  3  5    1        3  4   flatten       12  3  5  1  3  4

User · Answer

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 lt input length    i        let current   input i       for  let j 0  j lt current length    j          flattened push current j

User · Answer

Simple flatten util i ve written  const flatten    arr  result         gt        if   Array isArray arr            return     result  arr              arr forEach  a    gt             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

User · Answer

There is a confusingly hidden method  which constructs a new array without mutating the original one    x000D   x000D  var oldArray     1   2 3   4    x000D  var newArray   Array prototype concat apply     oldArray   x000D  console log newArray        1  2  3  4   x000D   x000D   x000D

User · Answer

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 lt a length  i             if a i  constructor    Array               r concat flattenArrayOfArrays a i   r             else              r push a i                        return r

User · Answer

flatten an array first level    method flatten    param array  Array     return  Array  flatten array    function flatten array      return array reduce  acc  current    gt  acc concat current                  flatten an array recursively    method flattenDeep    param array  Array     return  Array  flatten array    function flattenDeep array      return array reduce  acc  current    gt        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    gt        return Array isArray current    acc concat flattenDepth current  --depth     acc concat  current

User · Answer

Using the spread operator    x000D   x000D  const input       6       12       25       25       18       22       10     x000D  const output      concat    input   x000D  console log output      -- gt     6     12     25     25     18     22     10   x000D   x000D   x000D

User · Answer

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

User · Answer

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  gt                 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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

Here is the fastest solution in Typescript  which works also on arrays with multiple levels of nesting  export function flatten lt T gt  input  Array lt any gt   output  Array lt T gt         Array lt T gt        for  const value of input            Array isArray value    flatten value  output    output push value             return output     and than  const result   flatten lt MyModel gt  await Promise all promises

User · Answer

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   gt  Array isArray x        a   a reduce  x  y    gt  x concat y            Solution  2 let i   a findIndex x   gt  Array isArray x    while  i  gt  -1        a splice i  1     a i        i   a findIndex x   gt  Array isArray x

User · Answer

To flatten a two-dimensional array in one line     1  2    3  4  5   reduce Function prototype apply bind Array prototype concat        gt    1  2  3  4  5

User · Answer

ES6 way    x000D   x000D  const flatten   arr   gt  arr reduce  acc  next    gt  acc concat Array isArray next    flatten next    next       x000D   x000D  const a    1   2   3   4   5      x000D  console log flatten a   x000D   x000D   x000D    ES5 way for flatten function with ES3 fallback for N-times nested arrays    x000D   x000D  var flatten    function     x000D    if    Array prototype reduce  amp  amp    Array isArray    x000D      return function array    x000D        return array reduce function prev  next    x000D          return prev concat Array isArray next    flatten next    next   x000D                x000D         x000D      else   x000D      return function array    x000D        var arr       x000D        var i   0  x000D        var len   array length  x000D        var target  x000D   x000D        for    i  lt  len  i      x000D          target   array i   x000D          arr   arr concat  x000D             Object prototype toString call target        object Array      flatten target    target x000D             x000D          x000D   x000D        return arr  x000D         x000D      x000D        x000D   x000D  var a    1   2   3   4   5       x000D  console log flatten a    x000D   x000D   x000D

User · Answer

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

User · Answer

Sheer Magic of ES6  const flat   A   gt  A reduce  A  a    gt  Array isArray a        A     flat a         A  a

User · Answer

Array prototype flatten   Array prototype flatten    function         return    reduce call this  function flat  toFlatten            return flat concat Array isArray toFlatten    toFlatten flatten     toFlatten

User · Answer

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   gt    arr reduce       res  cur    gt          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

User · Answer

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  lt  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

User · Answer

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    gt      const flatList         arr forEach item   gt        Array isArray item         flatList push    deepFlatten item      recursive call        flatList push item          return flatList

User · Answer

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

User · Answer

I believe that the best way to do this would be something like this   var flatten   function        return    slice call arguments  toString   split

User · Answer

const flatten   array   gt  array reduce  a  b    gt  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

User · Answer

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 lt input length    i        var current   input i       for  var j 0  j lt current length    j          flattened push current j         DEMO  Hope It Helps

User · Answer

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

User · Answer

I didn t find here solution for large arrays when flattening is not deep  So  my version   function flatten arr       result          for  e of arr          result push    e      return result

User · Answer

I recommend a space-efficient generator function    x000D   x000D  function  flatten arr    x000D    if   Array isArray arr   yield arr  x000D    else for  let el of arr  yield  flatten el   x000D    x000D   x000D     Example  x000D  console log    flatten  1  2  3  4           1 2 3 4 x000D   x000D   x000D    If desired  create an array of flattened values as follows   let flattened       flatten  1  2  3  4            1  2  3  4

User · Answer

Much simpler and straight-forward one  with option to deep flatten   const flatReduce    arr  deep    gt        return arr reduce  acc  cur    gt            return acc concat Array isArray cur   amp  amp  deep   flatReduce cur  deep    cur                   console log flatReduce  1  2   3    4   5     false         gt   1 2 3 4  5  console log flatReduce  1  2   3    4   5   6  7  8      true         gt  1 2 3 4 5 6 7 8

User · Answer

ES-Next solutions   Array from   Set   Array flat   Array sort      1  remove duplicate item    2  flat array let arr      6      18        6       12       25       25       18       22       10      let result   Array from new Set arr flat Infinity      console log  flat array with unique filter   result           x000D   x000D     1  remove duplicate item x000D     2  sort by Asc order  munber only  x000D     3  flat array x000D   x000D     let arr      6      18        6       12       25       25       18       22       10     x000D   x000D  let arr     6     18       6      12      25      25      18      22      10     x000D   x000D  let result   Array from new Set arr flat Infinity    map Number  sort  a b   gt  a  gt  b   1  -1   x000D   x000D  console log  flat array with unique filter  amp  Asc sort   result   x000D     x000D   x000D   x000D        spread   Set   Array flat   Array sort      1  remove duplicate item    2  flat array let arr      6      18        6       12       25       25       18       22       10      let result       new Set arr flat Infinity      console log  flat array with unique filter   result           x000D   x000D     1  remove duplicate item x000D     2  sort by Asc order number only  x000D     3  flat array x000D   x000D    let arr      6      18        6       12       25       25       18       22       10     x000D   x000D  let arr     6     18       6      12      25      25      18      22      10     x000D   x000D  let result       new Set arr flat Infinity    map Number  sort  a b   gt  a  gt  b   1  -1   x000D   x000D  console log  flat array with unique filter  amp  Asc sort   result   x000D      x000D   x000D   x000D    refs  https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Array   https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Set  https   developer mozilla org en-US docs Web JavaScript Reference Operators Spread syntax

User · Answer

Another ECMAScript 6 solution in functional style   Declare a function    const flatten   arr   gt  arr reduce     a  b    gt  a concat Array isArray b    flatten b    b           and use it   flatten   1   2 3    4  5  6          - gt   1 2 3 4 5 6     x000D   x000D   const flatten   arr   gt  arr reduce  x000D            a  b    gt  a concat Array isArray b    flatten b    b      x000D            x000D   x000D   x000D  console log  flatten  1   2 3    4  5   6  7 8 9  10  11   12  13     x000D   x000D   x000D    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                        - gt   1  2  3  4    1  2   3  4   5  6    flat                - gt   1  2  3  4   5  6     1  2   3  4   5  6    flat 2              - gt   1  2  3  4  5  6    1  2   3  4   5  6    flat Infinity       - gt   1  2  3  4  5  6     x000D   x000D  let arr    1  2   3  4    x000D   x000D  console log  arr flat      x000D   x000D  arr     1  2   3  4   5  6     x000D   x000D  console log  arr flat      x000D  console log  arr flat 1     x000D  console log  arr flat 2     x000D  console log  arr flat Infinity     x000D   x000D   x000D

User · Answer

I have done it using recursion and closures  function flatten arr       var temp          function recursiveFlatten arr         for var i   0  i  lt  arr length  i            if Array isArray arr i              recursiveFlatten arr i            else           temp push arr i                        recursiveFlatten arr     return temp

User · Answer

just the best solution without lodash  let flatten   arr   gt     concat apply     arr map item   gt  Array isArray item    flatten item    item

User · Answer

Just to add to the great solutions  I used recursion to solve this               const flattenArray        gt                    let result                       return function flatten arr                        for  let i   0  i  lt  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

User · Answer

Here is the recursive way     function flatten arr       let newArray           for let i 0  i lt  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

User · Answer

You can use Ramda JS flatten    x000D   x000D  var arr     1 2    3    4 5    x000D  var flattenedArray   R flatten arr    x000D   x000D  console log flattenedArray  x000D   lt script src  https   cdnjs cloudflare com ajax libs ramda 0 25 0 ramda js  gt  lt  script gt  x000D   x000D   x000D

User · Answer

try this method    x000D   x000D  arr       6       12       25       25       18       22       10    x000D  concat arr   arr concat apply     arr  x000D  console log concat arr  x000D   x000D   x000D

User · Answer

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    gt  a concat b          js-fiddle  Mozilla docs

User · Answer

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

User · Answer

Using code from there   I would write   myArray enumerable   selectMany function x    return x     array

User · Answer

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   x000D   x000D     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    gt  array reduce     x  y    gt  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 lt strArr length i      strArr i  parseInt strArr i     console log strArr  x000D   x000D   x000D

User · Answer

Most of the answers here don t work on huge  e g  200 000 elements  arrays  and even if they do  they re slow  polkovnikov ph s answer has the best performance  but it doesn t work for deep flattening   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  lt  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

User · Answer

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  lt  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

User · Answer

var arrays      a      b    c     Array prototype concat apply     arrays       gives   a    b    c      I m just writing this as a separate answer  based on comment of  danhbear

User · Answer

Here is a version in Typescript based on the answer by artif3x  with a bonus implementation of flatMap for Scala fans   function flatten lt T gt  items  T       T       return items reduce  prev  next    gt  prev concat next           function flatMap lt T  U gt  items  T    f   t  T    gt  U     U       return items reduce  prev  next    gt  prev concat f next    new Array lt U gt

User · Answer

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   gt           arr reduce              acc  val    gt               Array isArray val                    acc concat deepFlatten val                     acc concat val                                 Both of methods return below result     1    a    b   2   4   3   c   5

User · Answer

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  lt  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

User · Answer

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

User · Answer

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  amp  amp  toFlatten length  gt  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

User · Answer

In Node environment  if your version is not support Array prototype flat but you use es6 or ts  then you can do like this  x000D   x000D  const arrays          6         12         25         25         18         22         10      const merged      concat    arrays    console log merged   x000D   x000D   x000D

User · Answer

A Haskellesque approach   x000D   x000D  function flatArray  x    xs    x000D    return x       Array isArray x    flatArray x     x      flatArray xs         x000D    x000D   x000D  var na     1 2   3  4 5    6 7    8  9    10   x000D      fa   flatArray na   x000D  console log fa   x000D   x000D   x000D

User · Answer

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

User · Answer

const common   arr reduce  a  b    gt      a     b

User · Answer

You can flatten an array of arrays using Array prototype reduce   and Array prototype concat     x000D   x000D  var data       6       12       25       25       18       22       10       0       15      3       75       5       100       7       3       75       5    reduce function a  b    x000D    return a concat b   x000D          x000D  console log data   x000D   x000D   x000D    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

User · Answer

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    x000D   x000D     concat      a   a   - gt   a  x000D  const concat    xs ys    gt  x000D    xs concat  ys  x000D   x000D     concatMap     a - gt   b   - gt   a  - gt   b  x000D  const concatMap   f   gt  xs   gt  x000D    xs map f  reduce concat      x000D   x000D     id    a - gt  a x000D  const id   x   gt  x000D    x x000D   x000D     flatten      a   - gt   a  x000D  const flatten   x000D    concatMap  id  x000D   x000D     your sample data x000D  const data   x000D        6       12       25       25       18       22       10    x000D   x000D  console log  flatten  data   x000D   x000D   x000D    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   x000D   x000D     Player     String  Number  - gt  Player x000D  const Player    name number    gt  x000D      name  number   x000D   x000D     team        Player  - gt  Team x000D  const Team       players    gt  x000D    players x000D   x000D     Game     Team  Team  - gt  Game x000D  const Game    teamA  teamB    gt  x000D      teamA  teamB   x000D   x000D     sample data x000D  const teamA   x000D    Team  Player   bob   5   Player   alice   6   x000D   x000D  const teamB   x000D    Team  Player   ricky   4   Player   julian   2   x000D   x000D  const game   x000D    Game  teamA  teamB  x000D   x000D  console log  game  x000D            bob   5       alice   6      x000D            ricky   4       julian   2       x000D   x000D   x000D    Ok  now say we want to print a roster that shows all the players that will be participating in game  hellip   const gamePlayers   game   gt    flatten  game   gamePlayers  game       gt       bob   5       alice   6       ricky   4       julian   2       If our flatten procedure flattened nested arrays too  we d end up with this garbage result  hellip   const gamePlayers   game   gt    badGenericFlatten game   gamePlayers  game       gt     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  hellip    x000D   x000D     concat      a   a   - gt   a  x000D  const concat    xs ys    gt  x000D    xs concat  ys  x000D   x000D     concatMap     a - gt   b   - gt   a  - gt   b  x000D  const concatMap   f   gt  xs   gt  x000D    xs map f  reduce concat      x000D   x000D     id    a - gt  a x000D  const id   x   gt  x000D    x x000D   x000D     flatten      a   - gt   a  x000D  const flatten   x000D    concatMap  id  x000D   x000D     deepFlatten      a   - gt   a  x000D  const deepFlatten   x000D    concatMap  x   gt  x000D      Array isArray  x    deepFlatten  x    x  x000D   x000D     your sample data x000D  const data   x000D     0   1   2   3   4  5   6      7   8    9  x000D   x000D  console log  flatten  data   x000D       0  1    2    3    4  5    6      7    8    9   x000D   x000D  console log  deepFlatten  data   x000D       0  1  2  3  4  5  6  7  8  9   x000D   x000D   x000D    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 - gt  b  a reducing function r     b a  - gt 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   x000D   x000D     mapReduce    a - gt  b   b a  - gt  b   b a  - gt  b  x000D  const mapReduce    m r    gt  x000D     acc x    gt  r  acc  m  x   x000D   x000D     concatMap     a - gt   b   - gt   a  - gt   b  x000D  const concatMap   f   gt  xs   gt  x000D    xs reduce  mapReduce  f  concat       x000D   x000D     concat      a   a   - gt   a  x000D  const concat    xs ys    gt  x000D    xs concat  ys  x000D   x000D     id    a - gt  a x000D  const id   x   gt  x000D    x x000D   x000D     flatten      a   - gt   a  x000D  const flatten   x000D    concatMap  id  x000D     x000D     deepFlatten      a   - gt   a  x000D  const deepFlatten   x000D    concatMap  x   gt  x000D      Array isArray  x    deepFlatten  x    x  x000D   x000D     your sample data x000D  const data   x000D          1  2    x000D          3  4      x000D          5  6    x000D          7  8       x000D   x000D  console log  flatten  data   x000D         1  2      3  4      5  6      7  8     x000D   x000D  console log  deepFlatten  data   x000D       1  2  3  4  5  6  7  8   x000D   x000D   x000D

User · Answer

You can use concat to merge arrays    x000D   x000D  var arrays     x000D       6    x000D       12    x000D       25    x000D       25    x000D       18    x000D       22    x000D       10   x000D     x000D  var merged      concat apply     arrays   x000D   x000D  console log merged   x000D   x000D   x000D    Using the apply method of concat will just take the second parameter as an array  so the last line is identical to this   var merged2      concat    6       12       25       25       18       22       10         There is also the Array prototype flat   method  introduced in ES2019  which you could use to flatten the arrays  although it is only available in Node js starting with version 11  and not at all in Internet Explorer    x000D   x000D  const arrays     x000D           6    x000D           12    x000D           25    x000D           25    x000D           18    x000D           22    x000D           10   x000D         x000D  const merge3   arrays flat 1     The depth level specifying how deep a nested array structure should be flattened  Defaults to 1  x000D  console log merge3   x000D       x000D   x000D   x000D

User · Answer

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

User · Answer

solve this problem using single line of code     x000D   x000D  function unflatten arr   x000D      return arr reduce  prevProps  nextProps    gt    x000D          return prevProps concat Array isArray nextProps    unflatten nextProps    nextProps  x000D             x000D    x000D   x000D   x000D    https   codepen io jyotishman pen BayVeoQ

User · Answer

function flatten input      let result            function extractArrayElements input        for let i   0  i  lt  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

User · Answer

You can use Array flat   with Infinity for any depth of nested array    x000D   x000D  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        x000D   x000D  let flatten   arr flat Infinity  x000D   x000D  console log flatten  x000D   x000D   x000D    check here for browser compatibility

User · Answer

let arr       6       12       25       25       18       22       10       0       15      3       75       5       100       7       3       75       5     arr   arr reduce  a  b    gt  a concat b       flattened

User · Answer

Use this method to flat two arrays arr1 concat    arr2

User · Answer

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

User · Answer

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 lt 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

User · Answer

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   gt        for let i   0  i  lt  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

[javascript] Merge/flatten an array of arrays

Examples related to javascript

Examples related to arrays

Examples related to flatten