Mam tablicę JavaScript, taką jak:

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

Jak miałbym przejść do scalania oddzielnych wewnętrznych tablic w jeden taki jak:

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

Możesz użyć concatdo scalenia tablic:

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

console.log(merged);

Użycie applymetody concatspowoduje pobranie drugiego parametru jako tablicy, więc ostatni wiersz jest identyczny z tym:

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

Istnieje również Array.prototype.flat()metoda (wprowadzona w ES2019), której można użyć do spłaszczenia tablic, chociaż jest ona dostępna tylko w Node.js od wersji 11, a wcale nie w Internet Explorerze .

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

Oto krótka funkcja, która wykorzystuje niektóre z nowszych metod tablic JavaScript do spłaszczenia n-wymiarowej tablicy.

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

Stosowanie:

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]

Istnieje myląco ukryta metoda, która konstruuje nową tablicę bez mutowania oryginalnej:

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

Najlepiej można to zrobić za pomocą funkcji redukcji 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);
}, []);

Lub z ES2015:

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

js-skrzypce

Dokumenty Mozilli

Istnieje nowa natywna metoda o nazwie flat, która dokładnie to robi.

(Pod koniec 2019 r. flatJest teraz publikowany w standardzie ECMA 2019 i core-js@3(biblioteka Babel) włącza go do swojej biblioteki wielopełniaczowej )

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

Większość odpowiedzi tutaj nie działa na ogromnych tablicach (np. 200 000 elementów), a nawet jeśli tak, są one powolne. Odpowiedź polkovnikov.ph ma najlepszą wydajność, ale nie działa w przypadku głębokiego spłaszczania.

Oto najszybsze rozwiązanie, które działa również na tablicach z wieloma poziomami zagnieżdżenia :

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

Przykłady

Ogromne tablice

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

Świetnie radzi sobie z dużymi tablicami. Na mojej maszynie wykonanie tego kodu zajmuje około 14 ms.

Zagnieżdżone tablice

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

Działa z zagnieżdżonymi tablicami. Ten kod tworzy [1, 1, 1, 1, 1, 1, 1, 1].

Tablice o różnych poziomach zagnieżdżenia

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

Nie ma żadnych problemów z takimi spłaszczonymi tablicami.

Aktualizacja: okazało się, że to rozwiązanie nie działa z dużymi tablicami. Jeśli szukasz lepszego, szybszego rozwiązania, sprawdź tę odpowiedź .

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

Po prostu rozwija się arri przekazuje jako argumenty concat(), które łączą wszystkie tablice w jedno. Jest to równoważne z [].concat.apply([], arr).

Możesz także wypróbować to dla głębokiego spłaszczenia:

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

Zobacz demo na JSBin .

Odniesienia do elementów ECMAScript 6 zastosowanych w tej odpowiedzi:

• Operator rozsiewu
• Funkcje strzałek

Uwaga dodatkowa: metody takie jak find()i funkcje strzałek nie są obsługiwane przez wszystkie przeglądarki, ale to nie znaczy, że nie możesz teraz korzystać z tych funkcji. Wystarczy użyć Babel - przekształca kod ES6 w ES5.

Możesz użyć podkreślenia :

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

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

Ogólne procedury oznaczają, że nie musimy przepisywać złożoności za każdym razem, gdy musimy zastosować określone zachowanie.

concatMap(lub flatMap) jest dokładnie tym, czego potrzebujemy w tej sytuacji.

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

dalekowzroczność

I tak, zgadłeś poprawnie, spłaszcza tylko jeden poziom, dokładnie tak, jak powinno działać

Wyobraź sobie taki zestaw danych

// 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, teraz powiedzmy, że chcemy wydrukować listę pokazującą wszystkich graczy, którzy wezmą udział w game…

const gamePlayers = game =>
  flatten (game)

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

Gdyby nasza flattenprocedura spłaszczyła również zagnieżdżone tablice, otrzymalibyśmy ten wynik śmieci…

const gamePlayers = game =>
  badGenericFlatten(game)

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

tarzać się głęboko, kochanie

Nie oznacza to, że czasami nie chcesz spłaszczać również zagnieżdżonych tablic - tylko takie zachowanie nie powinno być domyślne.

Z deepFlattenłatwością możemy wykonać procedurę…

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

Tam. Teraz masz narzędzie do każdego zadania - jedno do zgniatania jednego poziomu zagnieżdżenia flatteni jedno do niszczenia całego zagnieżdżaniadeepFlatten .

Może możesz to nazwać obliteratelub nukejeśli nie podoba ci się to imię deepFlatten.

Nie powtarzaj dwa razy!

Oczywiście powyższe implementacje są sprytne i zwięzłe, ale przy użyciu .mapwezwania do.reduce oznacza, że ​​faktycznie wykonujemy więcej iteracji niż to konieczne

Używanie sprawdzonego kombinatora, do którego dzwonię, mapReducepomaga utrzymać iteracje na minimalnym poziomie; przyjmuje funkcję mapowania m :: a -> b, funkcję redukującą r :: (b,a) ->bi zwraca nową funkcję redukującą - ten kombinator jest sercem przetworników ; jeśli jesteś zainteresowany, napisałem o nich inne odpowiedzi

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

Rozwiązanie dla bardziej ogólnego przypadku, gdy w tablicy mogą znajdować się elementy inne niż macierzowe.

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

Co z użyciem reduce(callback[, initialValue])metodyJavaScript 1.8

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

Zrobiłbym robotę.

Kolejne rozwiązanie ECMAScript 6 w funkcjonalnym stylu:

Zadeklaruj funkcję:

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

i użyj go:

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

Rozważ także natywną funkcję Array.prototype.flat () (propozycja dla ES6) dostępną w ostatnich wydaniach współczesnych przeglądarek. Dzięki @ (Константин Ван) i @ (Mark Amery) wspomnieli o tym w komentarzach.

flatFunkcja posiada jeden parametr określający oczekiwanej głębokości zagnieżdżenia tablicy, co równa się 1domyślnie.

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

Aby spłaszczyć tablicę tablic jednoelementowych, nie trzeba importować biblioteki, prosta pętla jest jednocześnie najprostszym i najbardziej wydajnym rozwiązaniem:

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

Do downvoters: przeczytaj pytanie, nie głosuj downvote, ponieważ to nie pasuje do twojego zupełnie innego problemu. To rozwiązanie jest zarówno najszybsze, jak i najprostsze dla zadanego pytania.

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

Uwaga: kiedy Function.prototype.apply([].concat.apply([], arrays) ) lub operator rozkładania ( [].concat(...arrays)) jest używany do spłaszczenia tablicy, oba mogą powodować przepełnienie stosu dla dużych tablic, ponieważ każdy argument funkcji jest przechowywany na stosie.

Oto bezpieczna implementacja w stosie w funkcjonalnym stylu, która porównuje najważniejsze wymagania względem siebie:

• wielokrotnego użytku
• czytelność
• zwięzłość
• wydajność

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

Gdy tylko przyzwyczaisz się do funkcji małych strzałek w formie curry, kompozycji funkcji i funkcji wyższego rzędu, kod ten brzmi jak proza. Programowanie polega zatem jedynie na złożeniu małych elementów, które zawsze działają zgodnie z oczekiwaniami, ponieważ nie zawierają żadnych skutków ubocznych.

ES6 One Line Spłaszcz

Zobacz lodash spłaszczony , podkreślenie spłaszczony (płytki true)

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

lub

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

Testowane z

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

Zobacz lodash flattenDeep , podkreślenie spłaszcz

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

Testowane z

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

Możesz używać Array.flat()z Infinitydowolną głębokością zagnieżdżonej tablicy.

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)

sprawdź tutaj zgodność przeglądarki

Podejście 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);

Sposób 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))

Sposób ES5 dla flattenfunkcji z rezerwą ES3 dla tablic zagnieżdżonych w liczbie N:

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

Jeśli masz tylko tablice z 1 elementem łańcuchowym:

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

wykona robotę. Bt, który konkretnie pasuje do Twojego przykładu kodu.

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

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

(Piszę to tylko jako osobną odpowiedź na podstawie komentarza @danhbear.)

Polecam funkcję generatora zajmującego mało miejsca :

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

W razie potrzeby utwórz tablicę spłaszczonych wartości w następujący sposób:

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

Wolałbym przekształcić całą tablicę taką, jaka jest, w ciąg znaków, ale w przeciwieństwie do innych odpowiedzi, zrobiłbym to przy użyciu, JSON.stringifya nie przy użyciu toString()metody, która daje niepożądany wynik.

Przy tym JSON.stringifywyjściu pozostaje tylko usunięcie wszystkich nawiasów, zawinięcie wyniku w nawiasy początkowe i końcowe i podanie wyniku, dzięki JSON.parsektóremu ciąg znaków powraca do „życia”.

• Może obsługiwać nieskończenie zagnieżdżone tablice bez żadnych kosztów prędkości.
• Może poprawnie obsługiwać elementy tablicy, które są ciągami zawierającymi przecinki.

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

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

console.log(flattened)

Uruchom fragment koduUkryj wyniki

Rozwiń fragment kodu

• Tylko dla wielowymiarowego zestawu ciągów / liczb (nie obiektów)

Możesz także wypróbować nową Array.Flat()metodę. Działa w następujący sposób:

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

console.log(arr);

The flat()Sposób tworzy się nową tablicę ze wszystkimi elementami macierzy sub-łączonych do niego rekurencyjnie do 1 warstwy na głębokość (tzn tablice wewnątrz macierzy)

Jeśli chcesz również spłaszczyć macierze trójwymiarowe lub nawet o wyższych wymiarach, wystarczy wywołać metodę płaską wiele razy. Na przykład (3 wymiary):

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

console.log(arr);

Bądź ostrożny!

Array.Flat()metoda jest stosunkowo nowa. Starsze przeglądarki takie jak np. Mogły nie wdrożyć tej metody. Jeśli chcesz, aby kod działał we wszystkich przeglądarkach, może być konieczne przeniesienie JS do starszej wersji. Sprawdź dokumenty MD dotyczące bieżącej zgodności przeglądarki.

Za pomocą operatora rozprzestrzeniania:

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

To nie jest trudne, po prostu powtarzaj tablice i łącz je:

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

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

Wygląda na to, że wygląda to na REKURS!

• Obsługuje wiele poziomów zagnieżdżania
• Obsługuje puste tablice i parametry nieszablonowe
• Nie ma mutacji
• Nie polega na nowoczesnych funkcjach przeglądarki

Kod:

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

Stosowanie:

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

Zrobiłem to za pomocą rekurencji i zamknięć

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

Pewnego dnia wygłupiałem się z Generatorami ES6 i napisałem tę treść . Który zawiera...

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

Zasadniczo tworzę generator, który zapętla oryginalną tablicę wejściową, jeśli znajdzie tablicę, używa operatora fed * w połączeniu z rekurencją w celu ciągłego spłaszczania wewnętrznych tablic. Jeśli element nie jest tablicą, po prostu daje pojedynczy element. Następnie za pomocą operatora Spread ES6 (aka splat operator) spłaszczam generator w nowej instancji tablicy.

Nie przetestowałem wydajności tego, ale wydaje mi się, że jest to ładny prosty przykład użycia generatorów i operatora fed *.

Ale znowu, po prostu wygłupiałem się, więc jestem pewien, że są bardziej wydajne sposoby, aby to zrobić.

tylko najlepsze rozwiązanie bez lodash

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