Tôi có một mảng JavaScript như:

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

Làm thế nào tôi có thể hợp nhất các mảng bên trong riêng biệt thành một như sau:

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

Bạn có thể sử dụng concatđể hợp nhất các mảng:

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

console.log(merged);

Sử dụng applyphương thức concatsẽ chỉ lấy tham số thứ hai dưới dạng một mảng, vì vậy dòng cuối cùng giống hệt như sau:

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

Ngoài ra còn có Array.prototype.flat()phương thức (được giới thiệu trong ES2019) mà bạn có thể sử dụng để làm phẳng các mảng, mặc dù nó chỉ có sẵn trong Node.js bắt đầu với phiên bản 11, và hoàn toàn không có trong 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);
    

Đây là một hàm ngắn sử dụng một số phương thức mảng JavaScript mới hơn để làm phẳng một mảng n chiều.

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

Sử dụng:

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]

Có một phương thức ẩn khó hiểu, nó xây dựng một mảng mới mà không làm thay đổi cái ban đầu:

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

Nó có thể được thực hiện tốt nhất bằng chức năng giảm 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);
}, []);

Hoặc, với ES2015:

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

js-fiddle

Tài liệu Mozilla

Có một phương pháp bản địa mới gọi là căn hộ để thực hiện điều này một cách chính xác.

(Tính đến cuối năm 2019, flathiện đã được xuất bản trong tiêu chuẩn ECMA 2019 và core-js@3(thư viện của babel) bao gồm nó trong thư viện polyfill của họ )

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

Hầu hết các câu trả lời ở đây không hoạt động trên các mảng lớn (ví dụ 200 000 phần tử) và ngay cả khi chúng có, chúng vẫn chậm. câu trả lời của Polkovnikov.ph có hiệu suất tốt nhất, nhưng nó không hoạt động để làm phẳng sâu.

Đây là giải pháp nhanh nhất, cũng hoạt động trên các mảng với nhiều cấp độ lồng nhau :

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

Ví dụ

Mảng lớn

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

Nó xử lý các mảng lớn chỉ tốt. Trên máy của tôi, mã này mất khoảng 14 ms để thực thi.

Mảng lồng nhau

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

Nó hoạt động với các mảng lồng nhau. Mã này sản xuất [1, 1, 1, 1, 1, 1, 1, 1].

Mảng với các cấp độ lồng khác nhau

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

Nó không có bất kỳ vấn đề với các mảng làm phẳng như thế này.

Cập nhật: hóa ra giải pháp này không hoạt động với các mảng lớn. Bạn đang tìm kiếm một giải pháp tốt hơn, nhanh hơn, hãy xem câu trả lời này .

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

Chỉ đơn giản là mở rộng arrvà chuyển nó dưới dạng đối số concat(), hợp nhất tất cả các mảng thành một. Nó tương đương với[].concat.apply([], arr) .

Bạn cũng có thể thử điều này để làm phẳng sâu:

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

Xem bản demo trên JSBin .

Tài liệu tham khảo cho các yếu tố ECMAScript 6 được sử dụng trong câu trả lời này:

• Toán tử trải
• Chức năng mũi tên

Lưu ý bên lề: các phương thức như find()và các chức năng mũi tên không được hỗ trợ bởi tất cả các trình duyệt, nhưng điều đó không có nghĩa là bạn không thể sử dụng các tính năng này ngay bây giờ. Chỉ cần sử dụng Babel - nó biến đổi mã ES6 thành ES5.

Bạn có thể sử dụng gạch dưới :

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

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

Các thủ tục chung có nghĩa là chúng ta không phải viết lại độ phức tạp mỗi lần chúng ta cần sử dụng một hành vi cụ thể.

concatMap(hoặc flatMap) chính xác là những gì chúng ta cần trong tình huống này.

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

tầm nhìn xa

Và vâng, bạn đã đoán đúng, nó chỉ làm phẳng một cấp độ, đó chính xác là cách nó nên làm việc

Hãy tưởng tượng một số dữ liệu được đặt như thế này

// 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, bây giờ nói rằng chúng ta muốn in một danh sách mà chương trình tất cả các cầu thủ sẽ được tham gia vào game...

const gamePlayers = game =>
  flatten (game)

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

Nếu flattenquy trình của chúng tôi cũng làm phẳng các mảng lồng nhau, chúng tôi sẽ kết thúc với kết quả rác này

const gamePlayers = game =>
  badGenericFlatten(game)

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

sâu, em bé

Điều đó không có nghĩa là đôi khi bạn cũng không muốn làm phẳng các mảng lồng nhau - chỉ đó không phải là hành vi mặc định.

Chúng tôi có thể làm một deepFlattenthủ tục dễ dàng

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

Đó Bây giờ bạn có một công cụ cho mỗi công việc - một công cụ flattenđể xóa một cấp độ lồng và một công cụ để xóa sổ tất cả các lồngdeepFlatten .

Có lẽ bạn có thể gọi nó obliteratehoặc nukenếu bạn không thích cái tên đó deepFlatten.

Đừng lặp lại hai lần!

Tất nhiên các triển khai trên là thông minh và súc tích, nhưng sử dụng .maptheo sau là một cuộc gọi đến.reduce có nghĩa là chúng ta thực sự đang thực hiện nhiều lần lặp hơn mức cần thiết

Sử dụng một tổ hợp đáng tin cậy mà tôi đang gọi mapReducegiúp giữ các lần lặp lại ở mức tối thiểu; nó có một chức năng ánh xạ m :: a -> b, một hàm khử r :: (b,a) ->bvà trả về một hàm khử mới - bộ kết hợp này là trung tâm của các bộ chuyển đổi ; nếu bạn quan tâm, tôi đã viết những câu trả lời khác về chúng

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

Một giải pháp cho trường hợp tổng quát hơn, khi bạn có thể có một số phần tử không phải là mảng trong mảng của bạn.

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

Để làm phẳng một mảng các mảng phần tử đơn, bạn không cần nhập thư viện, một vòng lặp đơn giản là giải pháp đơn giản và hiệu quả nhất:

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

Để downvoters: vui lòng đọc câu hỏi, đừng downvote vì nó không phù hợp với vấn đề rất khác của bạn. Giải pháp này là nhanh nhất và đơn giản nhất cho câu hỏi được hỏi.

Sử dụng reduce(callback[, initialValue])phương pháp nàoJavaScript 1.8

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

Sẽ làm công việc.

Một giải pháp ECMAScript 6 khác theo phong cách chức năng:

Khai báo một hàm:

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

và sử dụng 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]) )

Cũng xem xét một hàm riêng Array.prototype.flat () (đề xuất cho ES6) có sẵn trong các bản phát hành cuối cùng của trình duyệt hiện đại. Cảm ơn @ (Toàn cầu) và @ (Mark Amery) đã đề cập đến nó trong các bình luận.

Các flatchức năng có một tham số, xác định độ sâu dự kiến làm tổ mảng, bằng 1theo mặc định.

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

Xin lưu ý: Khi Function.prototype.apply( [].concat.apply([], arrays)) hoặc toán tử trải ([].concat(...arrays) ) được sử dụng để làm phẳng một mảng, cả hai đều có thể gây ra tràn ngăn xếp cho các mảng lớn, bởi vì mọi đối số của hàm được lưu trữ trên ngăn xếp.

Dưới đây là một triển khai ngăn xếp an toàn theo kiểu chức năng, cân nhắc các yêu cầu quan trọng nhất đối với nhau:

• tái sử dụng
• khả năng đọc
• sự đồng nhất
• hiệu suất

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

Ngay khi bạn quen với các hàm mũi tên nhỏ ở dạng bị cắt, thành phần hàm và các hàm bậc cao hơn, mã này sẽ đọc như văn xuôi. Lập trình sau đó chỉ bao gồm tập hợp các khối xây dựng nhỏ luôn hoạt động như mong đợi, vì chúng không chứa bất kỳ tác dụng phụ nào.

ES6 Một dòng phẳng

Xem lodash flatten , undererscore flatten (nông true)

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

hoặc là

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

Đã thử nghiệm với

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 Một dòng Deep Flatten

Xem lodash flattenDeep , gạch dưới gạch dưới

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

Đã thử nghiệm với

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

Bạn có thể sử dụng Array.flat()với Infinitybất kỳ độ sâu nào của mảng lồng nhau.

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)

kiểm tra ở đây để tương thích trình duyệt

Một cách tiếp cận 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);

Cách 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))

Cách ES5 cho flattenchức năng với dự phòng ES3 cho mảng lồng nhau N lầ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));

Nếu bạn chỉ có mảng với 1 phần tử chuỗi:

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

sẽ làm việc Bt đặc biệt phù hợp với ví dụ mã của bạn.

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

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

(Tôi chỉ viết đây là một câu trả lời riêng biệt, dựa trên nhận xét của @danhbear.)

Tôi đề nghị một chức năng tạo không gian hiệu quả :

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

Nếu muốn, tạo một mảng các giá trị dẹt như sau:

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

Tôi thà chuyển đổi toàn bộ mảng, theo nguyên trạng, thành một chuỗi, nhưng không giống như các câu trả lời khác, sẽ làm điều đó bằng cách sử dụng JSON.stringifyvà không sử dụng toString()phương thức, tạo ra kết quả không mong muốn.

Với JSON.stringifyđầu ra đó , tất cả những gì còn lại là xóa tất cả các dấu ngoặc, bao bọc kết quả bằng dấu ngoặc bắt đầu và kết thúc một lần nữa và phục vụ kết quả JSON.parseđể đưa chuỗi trở lại "cuộc sống".

• Có thể xử lý các mảng lồng vô hạn mà không có bất kỳ chi phí tốc độ.
• Có thể xử lý đúng các mục Array là chuỗi chứa dấu phẩy.

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

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

console.log(flattened)

Chạy đoạn mãẨn kết quả

Mở rộng đoạn trích

• Chỉ dành cho Mảng / Số nhiều chiều (không phải đối tượng)

Bạn cũng có thể thử Array.Flat()phương pháp mới . Nó hoạt động theo cách sau:

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

console.log(arr);

Các flat() phương pháp tạo ra một mảng mới với tất cả các yếu tố phụ mảng nối vào nó một cách đệ quy đến lớp 1 có chiều sâu (tức là mảng bên trong mảng)

Nếu bạn muốn làm phẳng các mảng 3 chiều hoặc thậm chí cao hơn, bạn chỉ cần gọi phương thức phẳng nhiều lần. Ví dụ: (3 chiều):

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

console.log(arr);

Hãy cẩn thận!

Array.Flat()phương pháp tương đối mới. Các trình duyệt cũ hơn như có thể không thực hiện phương thức này. Nếu bạn muốn mã của bạn hoạt động trên tất cả các trình duyệt, bạn có thể phải chuyển mã JS của bạn sang phiên bản cũ hơn. Kiểm tra tài liệu web MD để biết khả năng tương thích trình duyệt hiện tại.

Sử dụng toán tử trải rộng:

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

Điều đó không khó, chỉ cần lặp qua các mảng và hợp nhất chúng:

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

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

Có vẻ như đây là một công việc cho RECURSION!

• Xử lý nhiều cấp độ lồng
• Xử lý các mảng trống và các tham số không phải là mảng
• Không có đột biến
• Không phụ thuộc vào các tính năng trình duyệt hiện đại

Mã số:

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

Sử dụng:

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

Tôi đã thực hiện nó bằng cách sử dụng đệ quy và đóng

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

Tôi đã vui vẻ với ES6 Generators vào một ngày khác và đã viết ý chính này . Trong đó có ...

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

Về cơ bản, tôi đang tạo một trình tạo vòng lặp trên mảng đầu vào ban đầu, nếu nó tìm thấy một mảng, nó sử dụng toán tửield * kết hợp với đệ quy để liên tục làm phẳng các mảng bên trong. Nếu mục không phải là một mảng, nó chỉ mang lại một mục duy nhất. Sau đó, sử dụng toán tử lây lan ES6 (còn gọi là toán tử splat) Tôi làm phẳng trình tạo thành một thể hiện mảng mới.

Tôi đã không kiểm tra hiệu năng của việc này, nhưng tôi cho rằng đây là một ví dụ đơn giản tuyệt vời về việc sử dụng máy phát điện và toán tử suất *.

Nhưng một lần nữa, tôi chỉ ngốc nghếch nên tôi chắc chắn có nhiều cách hiệu quả hơn để làm điều này.

chỉ là giải pháp tốt nhất mà không cần lodash

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