泛型过程意味着我们不必在每次需要利用特定行为时重写复杂性。

concatMap（或flatMap）正是我们在这种情况下需要的。

//凹面：：（[a]，[a]）->[a]常量concat=（xs，ys）=>xs.concat（系统）//concatMap:：（a->[b]）->[a]->[b】常量concatMap=f=>xs=>xs.map（f）.reduce（concat，[]）//id：：a->a常量id=x=>x（x）//展平：：[[a]]->[a]常量展平=concatMap（id）//您的示例数据常量数据=[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]console.log（展平（数据））

远见

是的，你猜对了，它只会使一个层次变平，这正是它应该工作的方式

想象一下这样的数据集

//玩家：：（字符串，数字）->玩家常量玩家=（姓名，号码）=>[姓名、编号]//team:：（.Player）->团队const团队=（…玩家）=>玩家//游戏：：（团队，团队）->游戏常量游戏=（teamA，teamB）=>[团队A，团队B]//样本数据常量团队A=团队（球员（'ob'，5），球员（'lice'，6））常量组B=团队（球员（“恶心”，4），球员（“朱利安”，2））常量游戏=游戏（A队、B队）console.log（游戏）//[[鲍勃，5]，[爱丽丝，6]，//[['ricky'，4]，['julian'，2]]]

好的，现在假设我们要打印一份名册，显示所有将参加比赛的球员…

const gamePlayers = game =>
  flatten (game)

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

如果我们的展平过程也展平了嵌套数组，我们最终会得到这个垃圾结果…

const gamePlayers = game =>
  badGenericFlatten(game)

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

滚得很深，宝贝

这并不是说有时候你也不想压平嵌套的数组——只是这不应该是默认行为。

我们可以轻松地制作一个deepFlatten程序…

//凹面：：（[a]，[a]）->[a]常量concat=（xs，ys）=>xs.concat（系统）//concatMap:：（a->[b]）->[a]->[b】常量concatMap=f=>xs=>xs.map（f）.reduce（concat，[]）//id：：a->a常量id=x=>x（x）//展平：：[[a]]->[a]常量展平=concatMap（id）//deepFlatten：：[[a]]->[a]恒定深度展平=凹面贴图（x=>Array.isArray（x）？深度展平（x）：x）//您的示例数据常量数据=[0, [1, [2, [3, [4, 5], 6]]], [7, [8]], 9]console.log（展平（数据））// [ 0, 1, [ 2, [ 3, [ 4, 5 ], 6 ] ], 7, [ 8 ], 9 ]console.log（deepFlatten（数据））// [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

那里现在，每个作业都有一个工具——一个用于挤压一层嵌套、展平，另一个用于清除所有嵌套深度展平。

如果你不喜欢deepFlatten这个名字，也许你可以称之为毁灭或核武器。

不要重复两次！

当然，上面的实现是聪明和简洁的，但是使用.map后跟.reduce的调用意味着我们实际上要做的迭代超过了需要

使用我称之为mapReduce的可靠组合器，可以帮助将迭代保持在最小值；它采用一个映射函数m:：a->b，一个归约函数r:：（b，a）->b，并返回一个新的归约函数-这个组合子是换能器的核心；如果你感兴趣，我已经写了其他关于他们的答案

//mapReduce=（a->b，（b，a）->b，（a，b）->b）常量mapReduce=（m，r）=>（加速度，x）=>r（加速度，m（x））//concatMap:：（a->[b]）->[a]->[b】常量concatMap=f=>xs=>xs.reduce（mapReduce（f，concat），[]）//凹面：：（[a]，[a]）->[a]常量concat=（xs，ys）=>xs.concat（系统）//id：：a->a常量id=x=>x（x）//展平：：[[a]]->[a]常量展平=concatMap（id）//deepFlatten：：[[a]]->[a]恒定深度展平=凹面贴图（x=>Array.isArray（x）？深度展平（x）：x）//您的示例数据常量数据=[ [ [ 1, 2 ],[ 3, 4 ] ],[ [ 5, 6 ],[ 7, 8 ] ] ]console.log（展平（数据））// [ [ 1. 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]console.log（deepFlatten（数据））// [ 1, 2, 3, 4, 5, 6, 7, 8 ]

这是我的版本。它允许您将复杂的对象展平，可以在更多场景中使用：

输入

var input = {
   a: 'asdf',
   b: [1,2,3],
   c: [[1,2],[3,4]],
   d: {subA: [1,2]}
}

Code

功能如下：

function flatten (input, output) {

  if (isArray(input)) {
    for(var index = 0, length = input.length; index < length; index++){
      flatten(input[index], output);
    }
  }
  else if (isObject(input)) {
    for(var item in input){
      if(input.hasOwnProperty(item)){
        flatten(input[item], output);
      }
    }
  }
  else {
    return output.push(input);
  }
};

function isArray(obj) {
  return Array.isArray(obj) || obj.toString() === '[object Array]';
}

function isObject(obj) {
  return obj === Object(obj);
}

用法

var output = []

flatten(input, output);

输出

[“asdf”，1,2,3,1,2,3,4,1,2]

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

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

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

ES6方式：

constflatten=arr=>arr.reduce（（acc，next）=>acc.concat（Array.isArray（next）？flatten（next）：next），[]）常量a=[1，[2，[3，[4]，[5]]]]console.log（flatten（a））

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

var flatten=（函数）{if（！！Array.prototype.reduce&&！！Arrax.isArray）{返回函数（数组）{return array.reduce（函数（prev，next）{return prev.concat（Array.isArray（next）？flatten（next）：next）；}, []);};}其他{返回函数（数组）{var arr=[]；变量i=0；var len=阵列长度；var目标；对于（；i<len；i++）{目标=阵列[i]；arr=arr.concat(（Object.protype.toString.call（target）=='[Object Array]'）？展平（目标）：目标);}返回arr；};}}());var a=[1，[2，[3，[4，[5]]]]；console.log（flatten（a））；

/**
* 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回答这个问题，假设深度阵列是：

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

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

const flatArray = deepArray.flat(7);

但如果你不知道深度数组的深度，或者你的JavaScript引擎不支持像react原生JavaScriptCore那样的flat，请使用下面的JavaScript reduce函数：

 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]