这是最好的解决方法

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

我最初想使用.reduce方法并递归调用函数来展平内部数组，然而当你使用深度嵌套数组的深度嵌套数组时，这可能会导致堆栈溢出。使用concat也不是最好的方法，因为每次迭代都会创建数组的一个新的浅副本。我们可以做的是：

const flatten = arr => {for(let i = 0; i < arr.length;) {const val = arr[i];if(Array.isArray(val)) {arr.splice(i, 1, ...val);} else {i ++;}}return arr;}

我们不会通过concat创建新的数组，也不会递归调用任何函数。

http://jsbin.com/firiru/4/edit?js，控制台

我宁愿将整个数组按原样转换为字符串，但与其他答案不同，将使用JSON.stringify而不是使用toString()方法来执行此操作，这会产生不需要的结果。

使用JSON.stringify输出，剩下的就是删除所有括号，再次用开始和结束括号包装结果，并用JSON.parse提供结果，从而使字符串恢复“生命”。

• 可以处理无限嵌套数组而无需任何速度成本。
• 可以正确处理包含逗号的字符串的数组项。

var arr = ["abc",[[[6]]],["3,4"],"2"];
var s = "[" + JSON.stringify(arr).replace(/\[|]/g,'') +"]";var flattened = JSON.parse(s);
console.log(flattened)

• 仅适用于字符串/数字的多维数组（不是对象）

我提出了两个没有递归的简短解决方案。从计算复杂性的角度来看，它们不是最佳的，但在平均情况下工作得很好：

let a = [1, [2, 3], [[4], 5, 6], 7, 8, [9, [[10]]]];
// Solution #1while (a.find(x => Array.isArray(x)))a = a.reduce((x, y) => x.concat(y), []);
// Solution #2let i = a.findIndex(x => Array.isArray(x));while (i > -1){a.splice(i, 1, ...a[i]);i = a.findIndex(x => Array.isArray(x));}

适用于所有数据类型的递归版本

 /*jshint esversion: 6 */
// nested array for testinglet nestedArray = ["firstlevel", 32, "alsofirst", ["secondlevel", 456,"thirdlevel", ["theinnerinner", 345, {firstName: "Donald", lastName: "Duck"}, "lastinner"]]];
// wrapper function to protect inner variable tempArray from global scope;function flattenArray(arr) {
let tempArray = [];
function flatten(arr) {arr.forEach(function(element) {Array.isArray(element) ? flatten(element) : tempArray.push(element);     // ternary check that calls flatten() again if element is an array, hereby making flatten() recursive.});}
// calling the inner flatten function, and then returning the temporary arrayflatten(arr);return tempArray;}
// example usage:let flatArray = flattenArray(nestedArray);

/*** flatten an array first level* @method flatten* @param array {Array}* @return {Array} flatten array*/function flatten(array) {return array.reduce((acc, current) => acc.concat(current), []);}

/*** flatten an array recursively* @method flattenDeep* @param array {Array}* @return {Array} flatten array*/function flattenDeep(array) {return array.reduce((acc, current) => {return Array.isArray(current) ? acc.concat(flattenDeep(current)) : acc.concat([current]);}, []);}
/*** flatten an array recursively limited by depth* @method flattenDepth* @param array {Array}* @return {Array} flatten array*/function flattenDepth(array, depth) {if (depth === 0) {return array;}return array.reduce((acc, current) => {return Array.isArray(current) ? acc.concat(flattenDepth(current, --depth)) : acc.concat([current]);}, []);}

这里的逻辑是将输入数组转换为字符串并删除所有括号（[]）并将输出解析为数组。我为此使用ES6模板功能。

var x=[1, 2, [3, 4, [5, 6,[7], 9],12, [12, 14]]];
var y=JSON.parse(`[${JSON.stringify(x).replace(/\[|]/g,'')}]`);
console.log(y)

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

flatten函数的ES5方式，对于N次嵌套数组具有ES3回退：

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

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

根据要求，分解一行基本上是这样的。

function flatten(array) {// reduce traverses the array and we return the resultreturn array.reduce(function(acc, b) {// if is an array we use recursion to perform the same operations over the array we found// else we just concat the element to the accumulatorreturn acc.concat( Array.isArray(b) ? flatten(b) : b);}, []); // we initialize the accumulator on an empty array to collect all the elements}

我推荐一个节省空间的发生器函数：

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

如果需要，创建一个扁平化值数组，如下所示：

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

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

以下代码将展平深度嵌套的数组：

/*** [Function to flatten deeply nested array]* @param  {[type]} arr          [The array to be flattened]* @param  {[type]} flattenedArr [The flattened array]* @return {[type]}              [The flattened array]*/function flattenDeepArray(arr, flattenedArr) {let length = arr.length;
for(let i = 0; i < length; i++) {if(Array.isArray(arr[i])) {flattenDeepArray(arr[i], flattenedArr);} else {flattenedArr.push(arr[i]);}}
return flattenedArr;}
let arr = [1, 2, [3, 4, 5], [6, 7]];
console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4, 5 ], [ 6, 7 ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7 ]
arr = [1, 2, [3, 4], [5, 6, [7, 8, [9, 10]]]];
console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4 ], [ 5, 6, [ 7, 8, [Object] ] ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

ES6单线变平

请参见下划线展平，下划线展平（浅true）

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

或

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

测试与

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单线深展平

请参见下划线展平，下划线展平

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

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

您可以继续使用Array.flat（）方法来实现这一点，即使数组嵌套得多。

[1,2,3,[2]].flat()

相当于

[1,2,3,[2]].flat(1)

所以当你的嵌套增加时，你可以继续增加数量。

eg：

[1,[2,[3,[4]]]].flat(3) // [1, 2, 3, 4]

如果你不确定嵌套的级别，你可以将Infinity作为参数传递

[1,2,3,[2,[3,[3,[34],43],[34]]]].flat(Infinity) //[1, 2, 3, 2, 3, 3, 34, 43, 34]

您可以使用Ramda JS压平

var arr = [[1,2], [3], [4,5]];var flattenedArray = R.flatten(arr);
console.log(flattenedArray)

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.js"></script>

有一个名为平面的新本机方法可以准确地执行此操作。

（截至2019年底，flat现已在ECMA 2019标准中发布，core-js@3（Babel的库）将其包含在他们的polyill库中

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 deepconst arr3 = [2, 2, 5, [5, [5, [6]], 7]];arr3.flat(2);// [2, 2, 5, 5, 5, [6], 7];
// Flatten all levelsconst arr4 = [2, 2, 5, [5, [5, [6]], 7]];arr4.flat(Infinity);// [2, 2, 5, 5, 5, 6, 7];

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

只是为了增加伟大的解决方案。我使用递归来解决这个问题。

            const flattenArray = () => {let result = [];return function flatten(arr) {for (let i = 0; i < arr.length; i++) {if (!Array.isArray(arr[i])) {result.push(arr[i]);} else {flatten(arr[i])}}return result;}}

测试结果：https://codepen.io/ashermike/pen/mKZrWK

let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];arr = arr.reduce((a, b) => a.concat(b)); // flattened

我用ES6回答这个问题，假设深度数组是：

const deepArray = ['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];

如果您知道或猜测数组的深度不超过7这样的数字，请使用以下代码：

const flatArray = deepArray.flat(7);

但是，如果您不知道深度数组的深度，或者您的JavaScript引擎不支持flat（如react-nativeJavaScriptCore），请使用下面的函数，该函数用于JavaScriptreduce函数：

 const deepFlatten = arr =>arr.reduce((acc, val) =>Array.isArray(val)? acc.concat(deepFlatten(val)): acc.concat(val),[]);

这两个方法都返回以下结果：

["1", "a", "b", 2, "4", 3, "c", 5]

我有一个简单的解决方案，无需在特殊的js函数中使用。（

const input = [[0, 1], [2, 3], [4, 5]]let flattened=[];
for (let i=0; i<input.length; ++i) {let current = input[i];for (let j=0; j<current.length; ++j)flattened.push(current[j]);}

更简单和直接的一个；选择深扁平化；

const flatReduce = (arr, deep) => {return arr.reduce((acc, cur) => {return acc.concat(Array.isArray(cur) && deep ? flatReduce(cur, deep) : cur);}, []);};
console.log(flatReduce([1, 2, [3], [4, [5]]], false)); // =>  1,2,3,4,[5]console.log(flatReduce([1, 2, [3], [4, [5, [6, 7, 8]]]], true)); // => 1,2,3,4,5,6,7,8

您可以将#0和#1用于嵌套数组的任何深度。

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)

点击这里查看浏览器兼容性

最好在递归方式中执行，因此如果另一个数组中还有另一个数组，可以轻松地过滤…

const flattenArray = arr =>arr.reduce((res, cur) =>!Array.isArray(cur)? res.concat(cur): res.concat(flattenArray(cur)), []);

你可以这样称呼它：

flattenArray([[["Alireza"], "Dezfoolian"], ["is a"], ["developer"], [[1, [2, 3], ["!"]]]);

结果如下：

["Alireza", "Dezfoolian", "is a", "developer", 1, 2, 3, "!"]

这是一个基于artif3x答案的TypeScript版本，为Scala粉丝提供了flatMap的奖励实现。

function flatten<T>(items: T[][]): T[] {return items.reduce((prev, next) => prev.concat(next), []);}
function flatMap<T, U>(items: T[], f: (t: T) => U[]): U[] {return items.reduce((prev, next) => prev.concat(f(next)), new Array<U>());}

平坦阵列的制作方法

• 使用Es6平面（）
• 使用Es6 Reduce（）
• 使用递归
• 使用字符串操作

[1，[2，[3，[4，[5，[6,7]，8]，9]，10]]] - [1,2,3,4,5,6,7,8,9,10]

// using Es6 flat()let arr = [1,[2,[3,[4,[5,[6,7],8],9],10]]]console.log(arr.flat(Infinity))
// using Es6 reduce()let flatIt = (array) => array.reduce((x, y) => x.concat(Array.isArray(y) ? flatIt(y) : y), [])console.log(flatIt(arr))
// using recursionfunction myFlat(array) {let flat = [].concat(...array);return flat.some(Array.isArray) ? myFlat(flat) : flat;}console.log(myFlat(arr));
// using string manipulationlet strArr = arr.toString().split(',');for(let i=0;i<strArr.length;i++)strArr[i]=parseInt(strArr[i]);
console.log(strArr)

纯粹的魔法ES6

const flat = A => A.reduce((A, a) => Array.isArray(a) ? [...A, ...flat(a)] : [...A, a], []);

如果你用的是土豆泥，你可以用它的flatten方法：https://lodash.com/docs/4.17.14#flatten

Lodash的好处是它也有扁平化数组的方法：

递归：https://lodash.com/docs/4.17.14#flattenDeep

ii）多达n个嵌套级别：https://lodash.com/docs/4.17.14#flattenDepth

例如

const _ = require("lodash");const pancake =  _.flatten(array)

简单的扁平化直到我写

const flatten = (arr, result = []) => {if (!Array.isArray(arr)){return [...result, arr];}arr.forEach((a) => {result = flatten(a, result)})
return result}
console.log(flatten([1,[2,3], [4,[5,6,[7,8]]]])) // [ 1, 2, 3, 4, 5, 6, 7, 8 ]

在javascript中定义一个名为foo的数组数组，并使用javascript的数组concat内置方法将该数组展平为单个数组：

const foo = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]console.log({foo});
const bar = [].concat(...foo)console.log({bar});

应该打印：

{ foo:[ [ '$6' ],[ '$12' ],[ '$25' ],[ '$25' ],[ '$18' ],[ '$22' ],[ '$10' ] ] }{ bar: [ '$6', '$12', '$25', '$25', '$18', '$22', '$10' ] }

由于ES2019引入了平面和平面映射，因此任何数组都可以这样做：

const myArr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]const myArrFlat= myArr.flat(Infinity);console.log(myArrFlat); // ["$6", "$12", "$25", ...]

递归调用deepFlatten函数，这样我们就可以在不使用任何外部辅助方法的情况下扩展内部数组。

const innerArr = ['a', 'b'];const multiDimArr = [[1, 2], 3, 4, [5, 6, innerArr], 9];
const deepFlatten = (arr) => {const flatList = [];arr.forEach(item => {Array.isArray(item)? flatList.push(...deepFlatten(item)) // recursive call: flatList.push(item)});return flatList;}

此解决方案适用于数组的任何深度级别（指定嵌套数组结构的深度）。

function flatten(obj) {var out = [];function cleanElements(input) {for (var i  in input){if (input[i]instanceof Array){cleanElements(input[i]);}else {out.push(input[i]);}}}cleanElements(obj);return (out);}

您也可以尝试新的#0方法。它以以下方式工作：

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

flat()方法创建一个新数组，其中所有子数组元素递归连接到1层深度（即数组内的数组）

如果您还想展平3维甚至更高维的数组，您只需多次调用平面方法。例如（3维）：

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

小心！

#0方法相对较新。像ie这样的旧浏览器可能没有实现该方法。如果您希望您的代码在所有浏览器上运行，您可能必须将您的JS转换为旧版本。检查MDN web文档以了解当前浏览器的兼容性。

我认为array.flat（Infinity）是一个完美的解决方案。但是平面函数是一个相对较新的函数，可能无法在旧版本的浏览器中运行。我们可以使用递归函数来解决这个问题。

const arr = ["A", ["B", [["B11", "B12", ["B131", "B132"]], "B2"]], "C", ["D", "E", "F", ["G", "H", "I"]]]const flatArray = (arr) => {const res = []for (const item of arr) {if (Array.isArray(item)) {const subRes = flatArray(item)res.push(...subRes)} else {res.push(item)}}
return res}
console.log(flatArray(arr))

使用传播运算符：

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

这是递归方法…

function flatten(arr){let newArray = [];for(let i=0; i< arr.length; i++){if(Array.isArray(arr[i])){newArray =  newArray.concat(flatten(arr[i]))}else{newArray.push(arr[i])}}return newArray;}
console.log(flatten([1, 2, 3, [4, 5] ])); // [1, 2, 3, 4, 5]console.log(flatten([[[[1], [[[2]]], [[[[[[[3]]]]]]]]]]))  // [1,2,3]console.log(flatten([[1],[2],[3]])) // [1,2,3]

另一种使用jQuery$. map（）函数的方法。jQuery留档：

该函数可以返回一个值数组，该数组将被展平为完整数组。

var source = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];var target = $.map(source, function(value) { return value; }); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

使用此方法平坦两个数组

arr1.concat(...arr2);

function flatten(input) {let result = [];  
function extractArrayElements(input) {for(let i = 0; i < input.length; i++){if(Array.isArray(input[i])){extractArrayElements(input[i]);}else{result.push(input[i]);}}}  
extractArrayElements(input);  
return result;}

// let input = [1,2,3,[4,5,[44,7,8,9]]];// console.log(flatten(input));
// output [1,2,3,4,5,6,7,8,9]

这是打字稿中最快的解决方案，它也适用于具有多个嵌套级别的数组：

export function flatten<T>(input: Array<any>, output: Array<T> = []): Array<T> {for (const value of input) {Array.isArray(value) ? flatten(value, output) : output.push(value);}return output;}

而不是：

const result = flatten<MyModel>(await Promise.all(promises));

简单地使用扩展运算符，我们可以通过以下方式展平。

var OriginalArray = [[5, 1], [6], [2], [8]];var newArray = [];
for (let i = 0; i < OriginalArray.length; i++) {newArray.push(...OriginalArray[i]);}
console.log(newArray)

我刚刚尝试在不使用任何内置函数的情况下解决问题。

var arr = [1, 3, 4, 65, [3, 5, 6, 9, [354, 5, 43, 54, 54, 6, [232, 323, 323]]]];var result = [];
function getSingleArray(inArr) {for (var i = 0; i < inArr.length; i++) {if (typeof inArr[i] == "object") {getSingleArray(inArr[i]); // Calling Recursively} else {result.push(inArr[i]);}}}
getSingleArray(arr);console.log(result); // [1, 3, 4, 65, 3, 5, 6, 9, 354, 5, 43, 54, 54, 6, 232, 323, 323]

这是使用堆栈的非递归展平深度的解决方案。

    function flatten(input) {const stack = [...input];const res = [];while (stack.length) {const next = stack.pop();if (Array.isArray(next)) {stack.push(...next);} else {res.push(next);}}return res.reverse();}const arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];flatten(arrays);

const arr = [1, 2, [3, 4]];
arr.reduce((acc, val) => acc.concat(val), []);

如果您的编码环境支持ES6（ES2015），则无需编写任何递归函数或使用map、duce等数组方法。

一个简单的点差算子（…）将帮助您将数组的数组展平为单个数组

eg：

  const data = [[1, 2, 3], [4, 5],[2]]let res = []data.forEach(curSet=>{res = [...res,...curSet]})console.log(res) //[1, 2, 3, 4, 5, 2]

您可以使用"join（）"和//拆分//拆分：

let arrs = [["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];
let newArr = arrs.join(",").split(",");
console.log(newArr); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

此外，您还可以使用"toString（）"接口说明和//拆分//拆分：

let arrs = [["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];
let newArr = arrs.toString().split(",");
console.log(newArr); // ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

但是，如果字符串包含逗号，上述两种方式都无法正常工作：

"join（）"和//拆分//拆分：

let arrs = [["$,6"],["$,12"],["$2,5"],["$2,5"],[",$18"],["$22,"],["$,1,0"]];
let newArr = arrs.join(",").split(",");
console.log(newArr);// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]

let arrs = [["$,6"],["$,12"],["$2,5"],["$2,5"],[",$18"],["$22,"],["$,1,0"]];
let newArr = arrs.toString().split(",");
console.log(newArr);// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]