要展平单个元素数组的数组，不需要导入库，简单的循环是最简单和最有效的解决方案：

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

对反对选民：请阅读问题，不要因为它不适合你的不同问题而反对投票。对于所问的问题，此解决方案是最快和最简单的。

现在，实现这一点的最佳且简单的方法是这样连接和拆分阵列。

var multipleArrays = [["$6","$Demo"], ["$12",["Multi","Deep"]], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]]

var flattened = multipleArrays.join().split(",")

此解决方案适用于多个级别，也是一个线性解决方案。

DEMO

ECMAScript 6的EDIT

由于ECMAScript 6已经标准化，您可以更改操作[].contat.apply（[]，arrays）；对于[].contat（…数组）；

var flattened = [].concat(...input);

DEMO

EDIT最高效的解决方案

解决这个问题最有效的方法是使用循环。您可以在此处比较“ops/sec”速度

var flattened=[];
for (var i=0; i<input.length; ++i) {
    var current = input[i];
    for (var j=0; j<current.length; ++j)
        flattened.push(current[j]);
} 

DEMO

希望有帮助

我最初想使用.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安慰

前几天我和ES6发电机玩得很开心，写了这篇文章。其中包含。。。

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

基本上，我正在创建一个生成器，它在原始输入数组上循环，如果它找到一个数组，它将使用yield*运算符与递归相结合，以不断展平内部数组。如果项不是数组，则只生成单个项。然后使用ES6 Spread运算符（也称为splat运算符），我将生成器展平为一个新的数组实例。

我还没有测试它的性能，但我认为这是一个使用生成器和yield*运算符的简单示例。

但是，我又一次只是在偷懒，所以我相信有更多的表演方式可以做到这一点。

当您的数组中可能有一些非数组元素时，这是一种更一般情况的解决方案。

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

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