Ich habe ein JavaScript-Array wie:

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

Wie würde ich vorgehen, um die einzelnen inneren Arrays zu einem zusammenzuführen:

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

Sie können concatArrays zusammenführen:

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

console.log(merged);

Bei Verwendung der applyMethode von concatwird nur der zweite Parameter als Array verwendet, sodass die letzte Zeile mit dieser identisch ist:

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

Es gibt auch die Array.prototype.flat()in ES2019 eingeführte Methode, mit der Sie die Arrays reduzieren können, obwohl sie nur in Node.js ab Version 11 und überhaupt nicht in Internet Explorer verfügbar ist .

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

Hier ist eine kurze Funktion, die einige der neueren JavaScript-Array-Methoden verwendet, um ein n-dimensionales Array zu reduzieren.

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

Verwendungszweck:

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]

Es gibt eine verwirrend versteckte Methode, die ein neues Array erstellt, ohne das ursprüngliche zu mutieren:

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

Dies kann am besten mit der Javascript-Reduktionsfunktion erfolgen.

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

Oder mit ES2015:

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

js-Geige

Mozilla-Dokumente

Es gibt eine neue native Methode namens flat , um dies genau zu tun.

(Ab Ende 2019 flatist es jetzt im ECMA 2019-Standard veröffentlicht und core-js@3(Babels Bibliothek) enthält es in ihrer Polyfill- Bibliothek. )

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

Die meisten Antworten hier funktionieren nicht auf großen Arrays (z. B. 200 000 Elemente), und selbst wenn dies der Fall ist, sind sie langsam. Die Antwort von polkovnikov.ph hat die beste Leistung, funktioniert jedoch nicht bei tiefer Abflachung.

Hier ist die schnellste Lösung, die auch auf Arrays mit mehreren Verschachtelungsebenen funktioniert :

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

Beispiele

Riesige Arrays

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

Es handhabt große Arrays ganz gut. Auf meinem Computer dauert die Ausführung dieses Codes ca. 14 ms.

Verschachtelte Arrays

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

Es funktioniert mit verschachtelten Arrays. Dieser Code erzeugt [1, 1, 1, 1, 1, 1, 1, 1].

Arrays mit unterschiedlichen Verschachtelungsebenen

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

Es gibt keine Probleme mit dem Reduzieren von Arrays wie diesem.

Update: Es stellte sich heraus, dass diese Lösung nicht mit großen Arrays funktioniert. Wenn Sie nach einer besseren und schnelleren Lösung suchen, lesen Sie diese Antwort .

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

Is erweitert einfach arrund übergibt es als Argumente an concat(), wodurch alle Arrays zu einem zusammengeführt werden. Es ist gleichbedeutend mit [].concat.apply([], arr).

Sie können dies auch für eine tiefe Abflachung versuchen:

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

Siehe Demo auf JSBin .

Referenzen für ECMAScript 6-Elemente, die in dieser Antwort verwendet werden:

• Spread-Operator
• Pfeilfunktionen

Randnotiz: Methoden wie find()und Pfeilfunktionen werden nicht von allen Browsern unterstützt, dies bedeutet jedoch nicht, dass Sie diese Funktionen derzeit nicht verwenden können. Verwenden Sie einfach Babel - es wandelt ES6-Code in ES5 um.

Sie können Unterstrich verwenden :

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

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

Generische Prozeduren bedeuten, dass wir die Komplexität nicht jedes Mal neu schreiben müssen, wenn wir ein bestimmtes Verhalten verwenden müssen.

concatMap(oder flatMap) ist genau das, was wir in dieser Situation brauchen.

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

Voraussicht

Und ja, Sie haben es richtig erraten, es glättet nur eine Ebene, genau so sollte es funktionieren

Stellen Sie sich einen solchen Datensatz vor

// 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, jetzt sagen wir, wir möchten eine Liste drucken, in der alle Spieler aufgeführt sind, die teilnehmen werden game.

const gamePlayers = game =>
  flatten (game)

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

Wenn unsere flattenProzedur auch verschachtelte Arrays reduzieren würde, würden wir dieses Müllergebnis erhalten ...

const gamePlayers = game =>
  badGenericFlatten(game)

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

rollt tief, Baby

Das heißt nicht, dass Sie manchmal auch nicht verschachtelte Arrays reduzieren möchten - nur das sollte nicht das Standardverhalten sein.

Wir können deepFlattenmit Leichtigkeit ein Verfahren durchführen ...

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

Dort. Jetzt haben Sie für jeden Job ein Werkzeug - eines zum Quetschen einer Verschachtelungsebene flattenund eines zum Löschen aller Verschachtelungen deepFlatten.

Vielleicht kannst du es nennen obliterateoder nukewenn dir der Name nicht gefällt deepFlatten.

Nicht zweimal iterieren!

Natürlich sind die oben genannten Implementierungen clever und prägnant, aber .mapwenn .reducewir einen gefolgt von einem Aufruf von verwenden, bedeutet dies, dass wir tatsächlich mehr Iterationen als nötig durchführen

Die Verwendung eines vertrauenswürdigen Kombinators, den ich anrufe, mapReducehilft dabei, die Iterationen auf ein Minimum zu beschränken. Es übernimmt eine Abbildungsfunktion m :: a -> b, eine Reduktionsfunktion r :: (b,a) ->bund gibt eine neue Reduktionsfunktion zurück - dieser Kombinator ist das Herzstück der Wandler . Wenn Sie interessiert sind, habe ich andere Antworten darüber geschrieben

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

Eine Lösung für den allgemeineren Fall, wenn Sie möglicherweise einige Nicht-Array-Elemente in Ihrem Array haben.

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

Um ein Array von Einzelelement-Arrays zu reduzieren, müssen Sie keine Bibliothek importieren. Eine einfache Schleife ist sowohl die einfachste als auch die effizienteste Lösung:

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

Für Downvoter: Bitte lesen Sie die Frage, stimmen Sie nicht ab, da sie nicht zu Ihrem ganz anderen Problem passt. Diese Lösung ist sowohl die schnellste als auch die einfachste für die gestellte Frage.

Was ist mit der reduce(callback[, initialValue])Methode vonJavaScript 1.8

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

Würde den Job machen.

Eine weitere ECMAScript 6-Lösung im funktionalen Stil:

Deklarieren Sie eine Funktion:

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

und benutze es:

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

Betrachten Sie auch eine native Funktion Array.prototype.flat () (Vorschlag für ES6), die in den letzten Versionen moderner Browser verfügbar ist. Dank an @ (Константин Ван) und @ (Mark Amery) in den Kommentaren erwähnt.

Die flatFunktion verfügt über einen Parameter, der die erwartete Tiefe der Array-Verschachtelung angibt, die 1standardmäßig gleich ist.

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

Bitte beachten Sie: Wenn Function.prototype.apply( [].concat.apply([], arrays)) oder der Spread-Operator ( [].concat(...arrays)) verwendet werden, um ein Array zu reduzieren, können beide Stapelüberläufe für große Arrays verursachen, da jedes Argument einer Funktion auf dem Stapel gespeichert ist.

Hier ist eine stapelsichere Implementierung im funktionalen Stil, die die wichtigsten Anforderungen gegeneinander abwägt:

• Wiederverwendbarkeit
• Lesbarkeit
• Prägnanz
• 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));

Sobald Sie sich an kleine Pfeilfunktionen in Curryform, Funktionszusammensetzung und Funktionen höherer Ordnung gewöhnt haben, liest sich dieser Code wie Prosa. Die Programmierung besteht dann lediglich darin, kleine Bausteine ​​zusammenzustellen, die immer wie erwartet funktionieren, da sie keine Nebenwirkungen enthalten.

ES6 One Line Flatten

Siehe Lodash-Abflachung , Unterstrich-Abflachung (flach true)

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

oder

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

Getestet mit

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

Siehe lodash flattenDeep , unterstreichen Sie flatten

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

Getestet mit

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

Sie können Array.flat()mit Infinityfür jede Tiefe des verschachtelten Arrays verwenden.

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 hier für die Browser - Kompatibilität

Ein haskellesker Ansatz

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

ES6 Weg:

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- flattenFunktionsweise mit ES3-Fallback für N-mal verschachtelte 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));

Wenn Sie nur Arrays mit 1 Zeichenfolgenelement haben:

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

wird den Job machen. Bt, das speziell zu Ihrem Codebeispiel passt.

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

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

(Ich schreibe dies nur als separate Antwort, basierend auf dem Kommentar von @danhbear.)

Ich empfehle eine platzsparende Generatorfunktion :

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

Erstellen Sie bei Bedarf ein Array abgeflachter Werte wie folgt:

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

Ich würde lieber das gesamte Array so wie es ist in einen String umwandeln, aber im Gegensatz zu anderen Antworten würde ich dies mit JSON.stringifyder toString()Methode tun und nicht verwenden , was zu einem unerwünschten Ergebnis führt.

Bei dieser JSON.stringifyAusgabe müssen nur noch alle Klammern entfernt, das Ergebnis erneut mit Start- und Endklammern umbrochen und das Ergebnis bereitgestellt werden, mit JSON.parsedem die Zeichenfolge wieder zum "Leben" erweckt wird.

• Kann unendlich verschachtelte Arrays ohne Geschwindigkeitskosten verarbeiten.
• Kann Array-Elemente, bei denen es sich um Zeichenfolgen handelt, die Kommas enthalten, richtig verarbeiten.

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

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

console.log(flattened)

Führen Sie das Code-Snippet ausErgebnisse ausblenden

Erweitern Sie das Snippet

• Nur für mehrdimensionale Anordnungen von Zeichenfolgen / Zahlen (keine Objekte)

Sie können auch die neue Array.Flat()Methode ausprobieren . Es funktioniert folgendermaßen:

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

console.log(arr);

Die flat()Methode erstellt ein neues Array, in dem alle Subarray-Elemente bis zur Tiefebene 1 rekursiv verkettet sind (dh Arrays innerhalb von Arrays).

Wenn Sie auch dreidimensionale oder noch höherdimensionale Arrays reduzieren möchten, rufen Sie die flache Methode einfach mehrmals auf. Zum Beispiel (3 Dimensionen):

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

console.log(arr);

Achtung!

Array.Flat()Methode ist relativ neu. Ältere Browser wie z. B. haben die Methode möglicherweise nicht implementiert. Wenn Sie möchten, dass Ihr Code in allen Browsern funktioniert, müssen Sie Ihren JS möglicherweise auf eine ältere Version übertragen. Suchen Sie nach MD-Webdokumenten für die aktuelle Browserkompatibilität.

Verwenden des Spread-Operators:

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

Das ist nicht schwer, iterieren Sie einfach über die Arrays und führen Sie sie zusammen:

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

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

Es sieht so aus, als wäre dies ein Job für RECURSION!

• Behandelt mehrere Verschachtelungsebenen
• Behandelt leere Arrays und Nicht-Array-Parameter
• Hat keine Mutation
• Verlässt sich nicht auf moderne Browserfunktionen

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

Verwendungszweck:

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

Ich habe es mit Rekursion und Abschlüssen gemacht

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

Ich habe neulich mit ES6-Generatoren rumgespielt und dieses Wesentliche geschrieben . Was beinhaltet...

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

Grundsätzlich erstelle ich einen Generator, der das ursprüngliche Eingabearray durchläuft. Wenn er ein Array findet, verwendet er den Operatorield * in Kombination mit einer Rekursion, um die internen Arrays kontinuierlich zu reduzieren. Wenn das Element kein Array ist es nur liefert das einzelne Element. Dann reduziere ich den Generator mit dem ES6 Spread-Operator (auch bekannt als Splat-Operator) in eine neue Array-Instanz.

Ich habe die Leistung nicht getestet, aber ich denke, es ist ein schönes einfaches Beispiel für die Verwendung von Generatoren und des Yield * -Operators.

Aber auch hier habe ich nur vermasselt, also bin ich mir sicher, dass es dafür performantere Möglichkeiten gibt.

einfach die beste lösung ohne lodash

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