Saya memiliki larik JavaScript seperti:

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

Bagaimana saya bisa menggabungkan array batin terpisah menjadi seperti:

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

Anda dapat menggunakan concatuntuk menggabungkan array:

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

console.log(merged);

Menggunakan applymetode concathanya akan mengambil parameter kedua sebagai array, sehingga baris terakhir identik dengan ini:

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

Ada juga Array.prototype.flat()metode (diperkenalkan dalam ES2019) yang dapat Anda gunakan untuk meratakan array, meskipun hanya tersedia di Node.js dimulai dengan versi 11, dan tidak sama sekali di 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);
    

Berikut adalah fungsi singkat yang menggunakan beberapa metode array JavaScript yang lebih baru untuk meratakan array n-dimensi.

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

Pemakaian:

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]

Ada metode tersembunyi yang membingungkan, yang membangun array baru tanpa mengubah yang asli:

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

Ini bisa dilakukan dengan mengurangi fungsi javascript.

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);
}, []);

Atau, dengan ES2015:

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

js-biola

Mozilla docs

Ada metode asli baru yang disebut flat untuk melakukan ini dengan tepat.

(Sampai akhir 2019, flatsekarang diterbitkan dalam standar ECMA 2019, dan core-js@3(perpustakaan babel) memasukkannya ke perpustakaan polyfill mereka )

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];

Sebagian besar jawaban di sini tidak bekerja pada array besar (misalnya 200 000 elemen), dan bahkan jika itu, mereka lambat. Jawaban polkovnikov.ph memiliki kinerja terbaik, tetapi tidak berfungsi untuk meratakan.

Ini adalah solusi tercepat, yang juga berfungsi pada array dengan beberapa level sarang :

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;
};

Contohnya

Array besar

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

Ini menangani array besar dengan baik. Di komputer saya kode ini membutuhkan sekitar 14 ms untuk dijalankan.

Array bersarang

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

Ini bekerja dengan array bersarang. Kode ini menghasilkan [1, 1, 1, 1, 1, 1, 1, 1].

Array dengan berbagai tingkat sarang

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

Itu tidak memiliki masalah dengan meratakan array seperti ini.

Pembaruan: ternyata solusi ini tidak berfungsi dengan array besar. Jika Anda mencari solusi yang lebih baik, lebih cepat, periksa jawaban ini .

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

Hanya memperluas arrdan meneruskannya sebagai argumen concat(), yang menggabungkan semua array menjadi satu. Ini setara dengan[].concat.apply([], arr) .

Anda juga dapat mencoba ini untuk meratakan:

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
    )
  )
}

Lihat demo di JSBin .

Referensi untuk elemen ECMAScript 6 yang digunakan dalam jawaban ini:

• Operator yang tersebar
• Fungsi panah

Catatan sisi: metode suka find()dan fungsi panah tidak didukung oleh semua browser, tetapi itu tidak berarti bahwa Anda tidak dapat menggunakan fitur ini sekarang. Cukup gunakan Babel - ini mengubah kode ES6 menjadi ES5.

Anda dapat menggunakan Garis Bawah :

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

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

Prosedur umum berarti kita tidak perlu menulis ulang kompleksitas setiap kali kita perlu memanfaatkan perilaku tertentu.

concatMap(atau flatMap) persis apa yang kita butuhkan dalam situasi ini.

// 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))

tinjauan ke masa depan

Dan ya, Anda menebaknya dengan benar, itu hanya meratakan satu tingkat, yang persis bagaimana seharusnya bekerja

Bayangkan beberapa kumpulan data seperti ini

// 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 ] ] ]

Oke, sekarang katakan kita ingin mencetak daftar yang menunjukkan semua pemain yang akan berpartisipasi dalam game...

const gamePlayers = game =>
  flatten (game)

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

Jika flattenprosedur kami juga meratakan susunan bersarang, kami akan berakhir dengan hasil sampah ini ...

const gamePlayers = game =>
  badGenericFlatten(game)

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

berguling dalam, sayang

Itu bukan untuk mengatakan kadang-kadang Anda tidak ingin meratakan array bersarang, - hanya itu yang seharusnya tidak menjadi perilaku default.

Kita dapat membuat deepFlattenprosedur dengan mudah ...

// 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 ]

Sana. Sekarang Anda memiliki alat untuk setiap pekerjaan - satu untuk meremas satu tingkat sarang flatten,, dan satu untuk melenyapkan semua sarangdeepFlatten .

Mungkin Anda bisa menyebutnya obliterateatau nukejika Anda tidak suka namanya deepFlatten.

Jangan beralih dua kali!

Tentu saja implementasi di atas pintar dan ringkas, tetapi menggunakan .mapdiikuti oleh panggilan untuk.reduce berarti kita benar-benar melakukan lebih banyak iterasi daripada yang diperlukan

Menggunakan kombinator terpercaya saya menelepon mapReducemembantu menjaga iterasi ke minium; dibutuhkan fungsi pemetaan m :: a -> b, fungsi pereduksi r :: (b,a) ->bdan mengembalikan fungsi pereduksi baru - kombinator ini adalah jantung dari transduser ; jika Anda tertarik, saya sudah menulis jawaban lain tentang mereka

// 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 ]

Sebuah solusi untuk kasus yang lebih umum, ketika Anda mungkin memiliki beberapa elemen non-array di array Anda.

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

Untuk meratakan array array elemen tunggal, Anda tidak perlu mengimpor perpustakaan, loop sederhana adalah solusi paling sederhana dan paling efisien :

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

Untuk downvoters: harap baca pertanyaannya, jangan downvote karena tidak sesuai dengan masalah Anda yang sangat berbeda. Solusi ini adalah yang tercepat dan paling sederhana untuk pertanyaan yang diajukan.

Bagaimana dengan menggunakan reduce(callback[, initialValue])metodeJavaScript 1.8

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

Akan melakukan pekerjaan itu.

Solusi ECMAScript 6 lain dalam gaya fungsional:

Deklarasikan fungsi:

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

dan gunakan:

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]) )

Pertimbangkan juga fungsi asli Array.prototype.flat () (proposal untuk ES6) yang tersedia di rilis terbaru browser modern. Terima kasih kepada @ (Константин Ван) dan @ (Mark Amery) yang menyebutkannya di komentar.

The flatfungsi memiliki satu parameter, menentukan kedalaman diharapkan array bersarang, yang sama 1secara 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) );

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

Harap dicatat: Ketika Function.prototype.apply( [].concat.apply([], arrays)) atau operator penyebaran ( [].concat(...arrays)) digunakan untuk meratakan array, keduanya dapat menyebabkan stack overflow untuk array besar, karena setiap argumen dari suatu fungsi disimpan pada stack.

Berikut ini adalah implementasi stack-safe dengan gaya fungsional yang menimbang persyaratan yang paling penting terhadap satu sama lain:

• dapat digunakan kembali
• keterbacaan
• keringkasan yg padat isinya
• kinerja

// 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));

Segera setelah Anda terbiasa dengan fungsi panah kecil dalam bentuk kari, komposisi fungsi dan fungsi urutan lebih tinggi, kode ini berbunyi seperti prosa. Pemrograman kemudian hanya terdiri dari menyusun blok bangunan kecil yang selalu berfungsi seperti yang diharapkan, karena mereka tidak mengandung efek samping.

ES6 One Line Ratakan

Lihat Lodash rata , garis bawah rata (dangkal true)

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

atau

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

Diuji dengan

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

Lihat meratakan lodash , garis bawah rata

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

Diuji dengan

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]);
});

Anda dapat menggunakannya Array.flat()dengan Infinityuntuk kedalaman array bersarang.

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)

periksa di sini untuk kompatibilitas browser

Pendekatan Haskellesque

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);

Cara ES6:

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

Cara ES5 untuk flattenfungsi dengan fallback ES3 untuk array bertingkat N-kali:

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));

Jika Anda hanya memiliki array dengan 1 elemen string:

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

akan melakukan pekerjaan itu. Bt yang secara spesifik cocok dengan contoh kode Anda.

var arrays = [["a"], ["b", "c"]];
Array.prototype.concat.apply([], arrays);

// gives ["a", "b", "c"]

(Saya hanya menulis ini sebagai jawaban terpisah, berdasarkan komentar dari @danhbear.)

Saya merekomendasikan fungsi generator hemat ruang :

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

Jika diinginkan, buat array nilai rata sebagai berikut:

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

Saya lebih suka mengubah seluruh array, apa adanya, menjadi string, tetapi tidak seperti jawaban lain, akan melakukannya dengan menggunakan JSON.stringifydan tidak menggunakan toString()metode, yang menghasilkan hasil yang tidak diinginkan.

Dengan JSON.stringifyoutput itu, yang tersisa hanyalah menghapus semua tanda kurung, membungkus hasilnya dengan tanda tanda mulai & mengakhiri lagi, dan menyajikan hasil JSON.parseyang mengembalikan string ke "hidup".

• Dapat menangani array bersarang tanpa batas tanpa biaya kecepatan.
• Dapat dengan benar menangani item Array yang merupakan string yang mengandung koma.

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

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

console.log(flattened)

Jalankan cuplikan kodeSembunyikan hasil

Luaskan cuplikan

• Hanya untuk array multidimensi string / angka (bukan objek)

Anda juga dapat mencoba Array.Flat()metode baru . Ini bekerja dengan cara berikut:

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

console.log(arr);

Itu flat() Metode menciptakan sebuah array baru dengan semua elemen sub-array bersambung ke dalamnya secara rekursif hingga 1 lapisan kedalaman (yaitu array di dalam array)

Jika Anda juga ingin meratakan array 3 dimensi atau bahkan lebih tinggi, Anda cukup memanggil metode flat beberapa kali. Misalnya (3 dimensi):

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

console.log(arr);

Hati-hati!

Array.Flat()Metode ini relatif baru. Browser lama seperti mis. Mungkin belum menerapkan metode. Jika Anda ingin kode Anda berfungsi pada semua browser, Anda mungkin harus mengubah JS Anda ke versi yang lebih lama. Periksa MD web docs untuk kompatibilitas browser saat ini.

Menggunakan operator spread:

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

Itu tidak sulit, hanya mengulangi array dan menggabungkannya:

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

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

Sepertinya ini terlihat seperti pekerjaan untuk REKURSI!

• Menangani beberapa tingkat sarang
• Menangani parameter array dan non array kosong
• Tidak memiliki mutasi
• Tidak mengandalkan fitur browser modern

Kode:

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);
  }
};

Pemakaian:

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

Saya telah melakukannya menggunakan rekursi dan penutupan

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;
}

Saya bermain-main dengan Generator ES6 tempo hari dan menulis inti ini . Yang mengandung...

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);

Pada dasarnya saya membuat generator yang loop atas array input asli, jika menemukan array menggunakan operator hasil * dalam kombinasi dengan rekursi untuk terus meratakan array internal. Jika item tersebut bukan array, ia hanya menghasilkan item tunggal. Kemudian menggunakan operator Spread ES6 (alias operator percikan) saya meratakan generator menjadi contoh array baru.

Saya belum menguji kinerja ini, tapi saya pikir ini adalah contoh sederhana yang bagus untuk menggunakan generator dan operator hasil *.

Tapi sekali lagi, saya hanya bermain-main jadi saya yakin ada lebih banyak cara untuk melakukan ini.

hanya solusi terbaik tanpa lodash

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