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

[1,[2,3],[4,[5,6]]].reduce(function(p, c) {
    return p.concat(c instanceof Array ? 
                    c.reduce(arguments.callee, []) : 
                    [c]); 
}, []);

制作平面阵列的方法

使用Es6 flat（）使用Es6 reduce（）使用递归使用字符串操作

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

//使用Es6 flat（）设arr=[1，[2，[3，[4，[5，[6,7]，8]，9]，10]]]console.log（arr.flat（无限））//使用Es6 reduce（）let flatIt=（array）=>array.reduce(（x，y）=>x.concat（Array.isArray（y）？flatIt（y）：y），[])console.log（flatIt（arr））//使用递归函数myFlat（数组）{let flat=[].contat（…数组）；返回flat.some（Array.isArray）？myFlat（平面）：平面；}console.log（myFlat（arr））；//使用字符串操作let strArr=arr.toString（）.split（'，'）；for（设i=0；i<strArr.length；i++）strArr[i]=parseInt（strArr[i]）；console.log（strArr）

这并不难，只需遍历数组并合并它们：

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

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

我认为最好的方法是这样：

var flatten = function () {
  return [].slice.call(arguments).toString().split(',');
};

下面是现代浏览器的另一个深层次扁平化：

function flatten(xs) {
  xs = Array.prototype.concat.apply([], xs);
  return xs.some(Array.isArray) ? flatten(xs) : xs;
};