Bir JavaScript dizisi var:

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

Ayrı iç dizileri aşağıdaki gibi bir araya getirmeye nasıl giderim:

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

concatDizileri birleştirmek için kullanabilirsiniz :

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

console.log(merged);

applyYöntemini kullanmak, concatikinci parametreyi bir dizi olarak alır, bu nedenle son satır bununla aynıdır:

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

Ayrıca, Array.prototype.flat()dizileri düzleştirmek için kullanabileceğiniz (ES2019'da tanıtılan) yöntem de vardır , ancak Internet Explorer'da yalnızca 11 sürümünden başlayarak Node.js'de kullanılabilir .

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

Burada, n boyutlu bir diziyi düzleştirmek için yeni JavaScript dizisi yöntemlerinden bazılarını kullanan kısa bir işlev verilmiştir.

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

Kullanımı:

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]

Orijinali değiştirmeden yeni bir dizi oluşturan kafa karıştırıcı bir şekilde gizli bir yöntem var:

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

En iyi javascript azaltma fonksiyonu ile yapılabilir.

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

Veya ES2015 ile:

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

js-keman

Mozilla belgeleri

Bunu tam olarak yapmak için flat adı verilen yeni bir yerel yöntem var .

(2019'un sonlarından flatitibaren ECMA 2019 standardında yayınlanmaktadır ve core-js@3(babel'in kütüphanesi ) çoklu dolum kütüphanesine dahil etmektedir )

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

Buradaki cevapların çoğu devasa (örn. 200.000 eleman) dizilerde işe yaramıyor ve öyle olsalar bile yavaşlar. polkovnikov.ph'nin cevabı en iyi performansa sahiptir, ancak derin düzleştirme için işe yaramaz.

İşte birden fazla yuvalama düzeyine sahip dizilerde de çalışan en hızlı çözüm :

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

Örnekler

Büyük diziler

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

Büyük dizileri iyi işler. Makinemde bu kodun yürütülmesi yaklaşık 14 ms sürüyor.

İç içe diziler

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

İç içe dizilerle çalışır. Bu kod üretir [1, 1, 1, 1, 1, 1, 1, 1].

Farklı iç içe yerleştirme düzeylerine sahip diziler

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

Bunun gibi düzleştirici dizilerle herhangi bir sorunu yoktur.

Güncelleme: Bu çözümün büyük dizilerle çalışmadığı ortaya çıktı. Daha iyi, daha hızlı bir çözüm arıyorsanız, bu cevaba göz atın .

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

Basitçe genişler arrve concat()tüm dizileri bir araya getiren argüman olarak iletir. Eşdeğerdir [].concat.apply([], arr).

Bunu derin düzleştirme için de deneyebilirsiniz:

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

JSBin ile ilgili demoya bakın .

Bu cevapta kullanılan ECMAScript 6 öğeleri için referanslar:

• Forma operatörü
• Ok fonksiyonları

Yan not: find()ve ok işlevleri gibi yöntemler tüm tarayıcılar tarafından desteklenmez, ancak şu anda bu özellikleri kullanamayacağınız anlamına gelmez. Sadece Babel kullanın - ES6 kodunu ES5'e dönüştürür.

Alt Çizgi'yi kullanabilirsiniz :

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

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

Genel prosedürler, belirli bir davranışı her kullanmamız gerektiğinde karmaşıklığı yeniden yazmak zorunda olmadığımız anlamına gelir.

concatMap(veya flatMap) tam da bu durumda ihtiyacımız olan şeydir.

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

öngörü

Ve evet, sadece düzleştirir doğru tahmin biri o tam olarak nasıl olduğunu seviyesini, gerektiği çalışmak

Bunun gibi bir veri kümesi düşünün

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

Tamam, şimdi katılacak tüm oyuncuları gösteren bir liste yazdırmak istediğimizi söyleyin game…

const gamePlayers = game =>
  flatten (game)

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

Bizim ise flattenprosedürün fazla iç içe diziler düzleştirilmiş, biz bu çöp sonucu ile bitirmek istiyorum ...

const gamePlayers = game =>
  badGenericFlatten(game)

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

derin yuvarlanıyor bebeğim

Bu bazen iç içe dizileri de düzleştirmek istemediğiniz anlamına gelmez - bu sadece varsayılan davranış olmamalıdır.

deepFlattenKolaylıkla bir prosedür yapabiliriz …

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

Orada. Artık her bir iş için bir aracınız var - biri bir seviye iç içe yerleştirmeyi ezmek için flattenve diğeri tüm iç içe geçmişleri silmek içindeepFlatten .

Belki adlandırabilir obliterateveya nukeadını beğenmediyseniz deepFlatten.

İki kez yineleme!

Tabii ki yukarıdaki uygulamalar akıllı ve özlüdür, ancak .mapbunu bir çağrıyı kullanmak .reduceaslında gereğinden fazla yineleme yaptığımız anlamına gelir

Aradığım güvenilir bir birleştirici kullanmak mapReduceyinelemeleri bir minumda tutmaya yardımcı olur; bir eşleme işlevi m :: a -> b, bir azaltma işlevi alır r :: (b,a) ->bve yeni bir azaltma işlevi döndürür - bu birleştirici dönüştürücülerin kalbinde yer alır ; eğer ilgileniyorsanız, onlar hakkında başka cevaplar yazdım

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

Dizinizde dizi olmayan öğelerin olabileceği daha genel durum için bir çözüm.

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

Bir dizi tek eleman dizisini düzleştirmek için bir kitaplığı içe aktarmanıza gerek yoktur, basit bir döngü hem en basit hem de en verimli çözümdür:

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

Downvoters için: lütfen soruyu okuyun, çok farklı probleminize uymadığı için downvote etmeyin. Bu çözüm, sorulan soru için hem en hızlı hem de en basit çözümdür.

reduce(callback[, initialValue])Yöntemini kullanmaya ne dersinizJavaScript 1.8

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

İşi yapar.

İşlevsel tarzda bir başka ECMAScript 6 çözümü:

Bir işlev bildirin:

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

ve kullanın:

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

Modern tarayıcıların son sürümlerinde bulunan yerel bir işlev olan Array.prototype.flat () (ES6 için öneri ) de düşünün . @ (Константин Ван) ve @ (Mark Amery) sayesinde yorumlarda belirtti.

flatİşlev, bir parametre, eşit bir dizi iç içe geçme, beklenen derinliğinin önceden var 1varsayılan.

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

Lütfen dikkat: Bir diziyi düzleştirmek için Function.prototype.apply( [].concat.apply([], arrays)) veya forma operatörü ( [].concat(...arrays)) kullanıldığında, her iki işlev de büyük diziler için yığın taşmasına neden olabilir, çünkü bir işlevin her argümanı yığınta depolanır.

İşte fonksiyonel tarzda birbirine karşı en önemli gereksinimleri ağırlaştıran, yığın halinde güvenli bir uygulama:

• tekrar Kullanılabilirlik
• okunabilirliği
• özlülük
• verim

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

Körüklü form, fonksiyon kompozisyonu ve yüksek dereceli fonksiyonlardaki küçük ok fonksiyonlarına alışmaya başlar başlamaz bu kod düz yazı gibi okunur. Programlama daha sonra sadece beklendiği gibi çalışan küçük yapı taşlarının bir araya getirilmesinden oluşur, çünkü herhangi bir yan etki içermezler.

ES6 Tek Çizgi Düzleştir

Bkz lodash flatten , alt çizgi düzleştirmek (sığ true)

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

veya

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

İle test edildi

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 Tek Çizgi Derin Düzleştir

Bkz lodash flattenDeep , çizgi düzleştirmek

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

İle test edildi

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

İç içe dizinin herhangi bir derinliği için Array.flat()ile kullanabilirsiniz Infinity.

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)

tarayıcı uyumluluğu için buraya bakın

Haskellesque yaklaşımı

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 yolu:

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

flattenN-yuvalanmış diziler için ES3 yedekli işlev için ES5 yolu :

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

Yalnızca 1 dize öğesine sahip dizileriniz varsa:

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

işi yapacak. Bt özellikle kod örneğinizle eşleşir.

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

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

(@Danhbear'ın yorumuna dayanarak bunu ayrı bir cevap olarak yazıyorum.)

Yerden tasarruf sağlayan bir jeneratör fonksiyonu öneriyorum :

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

İstenirse, aşağıdaki gibi düzleştirilmiş değerler dizisi oluşturun:

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

Ben bütün dizeyi, olduğu gibi, bir dizeye dönüştürmek istiyorum, ama diğer cevapların aksine, bunu kullanarak JSON.stringifyve toString()istenmeyen bir sonuç üreten yöntemi, kullanmaz .

Bu JSON.stringifyçıktı ile geriye kalan tüm parantezleri kaldırmak, sonucu yine başlangıç ​​ve bitiş parantezleri ile sarmak JSON.parseve ipi "hayata" döndüren sonucu sunmaktır.

• Sonsuz iç içe dizileri herhangi bir hız maliyeti olmadan işleyebilir.
• Virgül içeren dizeler olan Dizi öğelerini doğru şekilde işleyebilir.

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

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

console.log(flattened)

Kod snippet'ini çalıştırSonuçları gizle

Snippet'i genişlet

• Yalnızca çok boyutlu Dizeler / Sayılar Dizisi için (Nesneler değil)

Ayrıca yeni Array.Flat()yöntemi de deneyebilirsiniz . Aşağıdaki şekilde çalışır:

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

console.log(arr);

flat()Yöntem derinliği 1 tabakaya ardışık kadar içine birleştirilmiş tüm alt dizi elemanları ile yeni bir dizi oluşturur (diziler içine, yani diziler)

3 boyutlu veya daha yüksek boyutlu dizileri de düzleştirmek istiyorsanız, düz yöntemi birden çok kez çağırmanız yeterlidir. Örneğin (3 boyut):

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

console.log(arr);

Dikkatli ol!

Array.Flat()yöntem nispeten yenidir. İe gibi daha eski tarayıcılar yöntemi uygulamamış olabilir. Kodun tüm tarayıcılarda çalışmasını istiyorsanız, JS'nizi daha eski bir sürüme aktarmanız gerekebilir. Geçerli tarayıcı uyumluluğu için MD web belgelerini kontrol edin.

Forma operatörünü kullanma:

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

Bu zor değil, sadece dizileri yineleyin ve birleştirin:

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

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

Bu, RECURSION için bir iş gibi görünüyor!

• Birden çok iç içe yerleştirme düzeyini yönetir
• Boş dizileri ve dizi olmayan parametreleri yönetir
• Mutasyon yok
• Modern tarayıcı özelliklerine güvenmez

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

Kullanımı:

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

Özyineleme ve kapanışları kullanarak yaptım

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

Geçen gün ES6 Jeneratörleri ile dalga geçiyordum ve bu özü yazdım . Hangi içerir ...

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

Temelde, orijinal diziler üzerinde döngü yapan bir jeneratör oluşturuyorum, eğer bir dizi bulursa , dahili dizileri sürekli olarak düzleştirmek için özyineleme ile birlikte verim * operatörünü kullanır . Öğe bir dizi değilse, yalnızca tek bir öğe verir . Sonra ES6 Spread operatörünü (splat operatörü olarak da bilinir) kullanarak jeneratörü yeni bir dizi örneğine yassılaştırdım.

Bunun performansını test etmedim, ancak jeneratörleri ve verim * operatörünü kullanmanın güzel basit bir örneği olduğunu düşünüyorum.

Ama yine de, sadece aptalca yapıyordum, bu yüzden bunu yapmanın daha performanslı yolları olduğundan eminim.

sadakatsiz en iyi çözüm

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