JavaScript专题之数组扁平化 #36

mqyqingfeng · 2017-07-21T03:03:24Z

扁平化

数组的扁平化，就是将一个嵌套多层的数组 array (嵌套可以是任何层数)转换为只有一层的数组。

举个例子，假设有个名为 flatten 的函数可以做到数组扁平化，效果就会如下：

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

知道了效果是什么样的了，我们可以去尝试着写这个 flatten 函数了

递归

我们最一开始能想到的莫过于循环数组元素，如果还是一个数组，就递归调用该方法：

// 方法 1
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        if (Array.isArray(arr[i])) {
            result = result.concat(flatten(arr[i]))
        }
        else {
            result.push(arr[i])
        }
    }
    return result;
}


console.log(flatten(arr))

toString

如果数组的元素都是数字，那么我们可以考虑使用 toString 方法，因为：

[1, [2, [3, 4]]].toString() // "1,2,3,4"

调用 toString 方法，返回了一个逗号分隔的扁平的字符串，这时候我们再 split，然后转成数字不就可以实现扁平化了吗？

// 方法2
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    return arr.toString().split(',').map(function(item){
        return +item
    })
}

console.log(flatten(arr))

然而这种方法使用的场景却非常有限，如果数组是 [1, '1', 2, '2'] 的话，这种方法就会产生错误的结果。

reduce

既然是对数组进行处理，最终返回一个值，我们就可以考虑使用 reduce 来简化代码：

// 方法3
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    return arr.reduce(function(prev, next){
        return prev.concat(Array.isArray(next) ? flatten(next) : next)
    }, [])
}

console.log(flatten(arr))

...

ES6 增加了扩展运算符，用于取出参数对象的所有可遍历属性，拷贝到当前对象之中：

var arr = [1, [2, [3, 4]]];
console.log([].concat(...arr)); // [1, 2, [3, 4]]

我们用这种方法只可以扁平一层，但是顺着这个方法一直思考，我们可以写出这样的方法：

// 方法4
var arr = [1, [2, [3, 4]]];

function flatten(arr) {

    while (arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr);
    }

    return arr;
}

console.log(flatten(arr))

undercore

那么如何写一个抽象的扁平函数，来方便我们的开发呢，所有又到了我们抄袭 underscore 的时候了~

在这里直接给出源码和注释，但是要注意，这里的 flatten 函数并不是最终的 _.flatten，为了方便多个 API 进行调用，这里对扁平进行了更多的配置。

/**
 * 数组扁平化
 * @param  {Array} input   要处理的数组
 * @param  {boolean} shallow 是否只扁平一层
 * @param  {boolean} strict  是否严格处理元素，下面有解释
 * @param  {Array} output  这是为了方便递归而传递的参数
 * 源码地址：https://github.com/jashkenas/underscore/blob/master/underscore.js#L528
 */
function flatten(input, shallow, strict, output) {

    // 递归使用的时候会用到output
    output = output || [];
    var idx = output.length;

    for (var i = 0, len = input.length; i < len; i++) {

        var value = input[i];
        // 如果是数组，就进行处理
        if (Array.isArray(value)) {
            // 如果是只扁平一层，遍历该数组，依此填入 output
            if (shallow) {
                var j = 0, length = value.length;
                while (j < length) output[idx++] = value[j++];
            }
            // 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output
            else {
                flatten(value, shallow, strict, output);
                idx = output.length;
            }
        }
        // 不是数组，根据 strict 的值判断是跳过不处理还是放入 output
        else if (!strict){
            output[idx++] = value;
        }
    }

    return output;

}

解释下 strict，在代码里我们可以看出，当遍历数组元素时，如果元素不是数组，就会对 strict 取反的结果进行判断，如果设置 strict 为 true，就会跳过不进行任何处理，这意味着可以过滤非数组的元素，举个例子：

var arr = [1, 2, [3, 4]];
console.log(flatten(arr, true, true)); // [3, 4]

那么设置 strict 到底有什么用呢？不急，我们先看下 shallow 和 strct 各种值对应的结果：

shallow true + strict false ：正常扁平一层
shallow false + strict false ：正常扁平所有层
shallow true + strict true ：去掉非数组元素
shallow false + strict true ：返回一个[]

我们看看 underscore 中哪些方法调用了 flatten 这个基本函数：

_.flatten

首先就是 _.flatten：

_.flatten = function(array, shallow) {
    return flatten(array, shallow, false);
};

在正常的扁平中，我们并不需要去掉非数组元素。

_.union

接下来是 _.union：

该函数传入多个数组，然后返回传入的数组的并集，

举个例子：

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]

如果传入的参数并不是数组，就会将该参数跳过：

_.union([1, 2, 3], [101, 2, 1, 10], 4, 5);
=> [1, 2, 3, 101, 10]

为了实现这个效果，我们可以将传入的所有数组扁平化，然后去重，因为只能传入数组，这时候我们直接设置 strict 为 true，就可以跳过传入的非数组的元素。

// 关于 unique 可以查看《JavaScript专题之数组去重》[](https://github.com/mqyqingfeng/Blog/issues/27)
function unique(array) {
   return Array.from(new Set(array));
}

_.union = function() {
    return unique(flatten(arguments, true, true));
}

_.difference

是不是感觉折腾 strict 有点用处了，我们再看一个 _.difference：

语法为：

_.difference(array, *others)

效果是取出来自 array 数组，并且不存在于多个 other 数组的元素。跟 _.union 一样，都会排除掉不是数组的元素。

举个例子：

_.difference([1, 2, 3, 4, 5], [5, 2, 10], [4], 3);
=> [1, 3]

实现方法也很简单，扁平 others 的数组，筛选出 array 中不在扁平化数组中的值：

function difference(array, ...rest) {

    rest = flatten(rest, true, true);

    return array.filter(function(item){
        return rest.indexOf(item) === -1;
    })
}

注意，以上实现的细节并不是完全按照 underscore，具体细节的实现感兴趣可以查看源码。

专题系列

JavaScript专题系列目录地址：https://github.com/mqyqingfeng/Blog。

JavaScript专题系列预计写二十篇左右，主要研究日常开发中一些功能点的实现，比如防抖、节流、去重、类型判断、拷贝、最值、扁平、柯里、递归、乱序、排序等，特点是研(chao)究(xi) underscore 和 jQuery 的实现方式。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。

FrontToEnd · 2017-07-24T05:17:48Z

日常观光+学习

kankk · 2017-07-26T09:54:06Z

学习了

xiaobinwu · 2017-11-05T04:44:14Z

学习了，之后应该可以用到

sulingLiang · 2018-03-02T07:33:11Z

为什么“如果数组是 [1, '1', 2, '2'] 的话，这种方法就会产生错误的结果。”，可以解释一下吗？因为我运行了，是没问题的

HuangQiii · 2018-03-02T07:35:33Z

@sulingLiang 扁平化不改变原数据啊，你的结果也显示了，string型的变成了数字都

mqyqingfeng · 2018-03-08T06:27:40Z

@HuangQiii 感谢回答~ (๑•̀ㅂ•́)و✧

swpuLeo · 2018-04-11T08:12:33Z

楼主你好，我发现你的 flatten() 有点问题：

先看 underscore 的：

const _ = require('underscore');
console.log(_.flatten([1, [2, [3, 4]], 5], false)); // [ 1, 2, 3, 4, 5 ]
console.log(_.flatten([1, [2, [3, 4]], 5], true)); // [ 1, 2, [ 3, 4 ], 5 ]

而楼主你的 flatten() 函数的表现如下：

/**
 * 数组扁平化
 * @param  {Array} input   要处理的数组
 * @param  {boolean} shallow 是否只扁平一层
 * @param  {boolean} strict  是否严格处理元素，下面有解释
 * @param  {Array} output  这是为了方便递归而传递的参数
 * 源码地址：https://github.com/jashkenas/underscore/blob/master/underscore.js#L528
 */
function flatten(input, shallow, strict, output) {

    // 递归使用的时候会用到output
    output = output || [];
    var idx = output.length;

    for (var i = 0, len = input.length; i < len; i++) {

        var value = input[i];
        // 如果是数组，就进行处理
        if (Array.isArray(value)) {
            // 如果是只扁平一层，遍历该数组，依此填入 output
            if (shallow) {
                var j = 0,
                    len = value.length;
                while (j < len) output[idx++] = value[j++];
            }
            // 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output
            else {
                flatten(value, shallow, strict, output);
                idx = output.length;
            }
        }
        // 不是数组，根据 strict 的值判断是跳过不处理还是放入 output
        else if (!strict) {
            output[idx++] = value;
        }
    }

    return output;

}

console.log(flatten([1, [2, [3, 4]], 5], false, false)); // [ 1, 2, 3, 4, 5 ]
console.log(flatten([1, [2, [3, 4]], 5], true, false)); // [ 1, 2, [ 3, 4 ] ] 这里与 underscore 不一致

Debug 发现，楼主的 len 发生了变化，原来是楼主的 flatten() 函数中声明了两次 len 变量，将第二个 len 换个名字就行了。

var j = 0,
    len = value.length;  // 改为 length = value.length

mqyqingfeng · 2018-04-13T10:47:10Z

@swpuLeo 感谢指出哈 (๑•̀ㅂ•́)و✧ 确实有问题，我自己测试了一下，除了改成 var length = value.length 之外，while (j < len) output[idx++] = value[j++]; 这里的 len 也需要改成 length

thereisnowinter · 2018-04-16T04:53:39Z

数组扁平化还可以这么写,不过初学者理解不了。

flatten = Function.apply.bind([].concat, [])

Tan90Qian · 2018-04-17T09:14:12Z

@mqyqingfeng 看到dalao用concat和扩展运算符的时候愣了一下，几乎完全这个方法的印象，甚至还是去查了文档才知道如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。这一点的。。。dalao你除了面试、写这些博客时候，日常开发中哪里会用到concat么？我之前半年似乎这个方法连5次都没用到

Tan90Qian · 2018-04-17T12:03:20Z

@thereisnowinter dalao 666～萌新学到了新的一手 apply和bind连用，同时绑定调用的方法和调用的主体，只留下一个参数的位置

mqyqingfeng · 2018-04-24T14:08:49Z

@thereisnowinter 666~ 为你打 call~

稍微解释一下：

Function.apply.bind([].concat, [])

// 相当于

function(arg) {
  return Function.apply.call([].concat, [], arg)
}

// 相当于

function(arg) {
  return [].concat.apply([], arg)
}

// 相当于
// 这里错了
function(arg) {
   return [].concat(arg)
}

// 应该是

function(arg) {
   return [].concat(...arg)
}

mqyqingfeng · 2018-04-24T14:10:19Z

@Tan90Qian 处理数据或者需要返回一个新数组的时候，会用到 concat

Tan90Qian · 2018-04-24T15:31:51Z

@mqyqingfeng 那基本就是在不能使用es6的情况下使用咯？否则“扩展操作符”+数组直接量的创建方式基本可以替代它的功能。然后就是类似数组展平这样，仅靠一个concat或者扩展操作符无法完成的功能。

PS：刚写的内容有2个问题，

因为是用了bind，所以“相当于”下的代码应该都是return function而不是直接function；
由于第三个函数是从第二个函数应用了apply之后转过去的，所以转化出来的结果应该是将arg参数拆开后再传入的结果，也就是借助了eval或者rest操作符的版本

return function(arg) {
  return [].concat(...arg)
}

这也和博主大大在正文中的版本一致。

mqyqingfeng · 2018-04-25T02:31:14Z

@Tan90Qian 关于这两个问题：

不需要 return function 吧？

var flatten = Function.apply.bind([].concat, [])

// 相当于

var flatten = function(arg) {
  return Function.apply.call([].concat, [], arg)
}

正好就是对应的，不需要 return function 呀

嗯……也不需要吧，arg 本身就会传入一个数组，concat 也支持直接传入一个数组，不需要展开呀

Tan90Qian · 2018-04-25T12:48:06Z

@mqyqingfeng 第一条是我弄错了。不过第二条，确实是需要展开的，因为MDN对concat方法的描述：如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组，因此

[].concat([1,[2,[3,4]]])  // [1,[2,[3,4]]]
[].concat(...[1,[2,[3,4]]])
// 相当于
[].concat(1,[2,[3,4]]) // [1,2,[3,4]]

mqyqingfeng · 2018-04-25T13:45:15Z

@Tan90Qian 啊，是的，感谢指出~

Fiv5 · 2018-04-26T10:51:14Z

博主你好，我看到“前端大牛爱好者”最新期是你的关于 this 的博文，不知道有没有经过你同意，特此跟你告知一声。 | | Func. | | 邮箱：15168273390@163.com | 签名由网易邮箱大师定制在2018年04月25日 21:45，冴羽写道： @Tan90Qian 啊，是的，感谢指出~ — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or mute the thread.

Fiv5 · 2018-04-26T10:51:38Z

补充一下，是微信公众号 | | Func. | | 邮箱：15168273390@163.com | 签名由网易邮箱大师定制在2018年04月26日 18:50，Func. 写道：博主你好，我看到“前端大牛爱好者”最新期是你的关于 this 的博文，不知道有没有经过你同意，特此跟你告知一声。 | | Func. | | 邮箱：15168273390@163.com | 签名由网易邮箱大师定制在2018年04月25日 21:45，冴羽写道： @Tan90Qian 啊，是的，感谢指出~ — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or mute the thread.

Latube · 2018-04-26T11:02:34Z

那个公众号很水的，转载了很多别人的文章，作者是某一培训机构的招生老师，等着你上钩呢??????，总之，没多少是原创的文章获取 Outlook for Android<https://aka.ms/ghei36>

…

________________________________ From: King Muji <notifications@github.com> Sent: Thursday, April 26, 2018 6:51:25 PM To: mqyqingfeng/Blog Cc: Subscribed Subject: Re: [mqyqingfeng/Blog] JavaScript专题之数组扁平化 (#36) 博主你好，我看到“前端大牛爱好者”最新期是你的关于 this 的博文，不知道有没有经过你同意，特此跟你告知一声。 | | Func. | | 邮箱：15168273390@163.com | 签名由网易邮箱大师定制在2018年04月25日 21:45，�暧写道： @Tan90Qian 啊，是的，感谢指出~ ― You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or mute the thread. ― You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub<https://eur03.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Fmqyqingfeng%2FBlog%2Fissues%2F36%23issuecomment-384596737&data=02%7C01%7C%7C4d5e4744d4bb4e1e94c708d5ab63a8b3%7C84df9e7fe9f640afb435aaaaaaaaaaaa%7C1%7C0%7C636603366881442453&sdata=k9mfH9JOb1%2Fz4gSkNOxZB53JsOaZTDKicu4iVi%2BG%2FPc%3D&reserved=0>, or mute the thread<https://eur03.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Fnotifications%2Funsubscribe-auth%2FAR4207OycI7_ypWBO5tIoSBwy-ogl6cNks5tsaatgaJpZM4Oe52j&data=02%7C01%7C%7C4d5e4744d4bb4e1e94c708d5ab63a8b3%7C84df9e7fe9f640afb435aaaaaaaaaaaa%7C1%7C0%7C636603366881442453&sdata=miIRaQrwYKI69bVt1qp7LFBrkGnNbCc7%2BTy7IfkOXC0%3D&reserved=0>.

mqyqingfeng · 2018-04-26T11:16:09Z

@Fiv5 感谢告知~ 我并不知道这件事情，请教大家这种情况该怎么处理呢？

delayk · 2018-04-27T02:27:43Z

@mqyqingfeng 微信公众号文章的话直接投诉就可以吧，有一个“未经授权的文章”选项

huyong007 · 2018-07-26T07:54:30Z

/* 在javascript权威指南的第六版，p159*/
var objects=[{x:1,a:1},{y:2,a:2},{z:3,a:3}];
var leftunion=objects.reduce(union);//{x:1,y:2,z:3,a:1}
var rightunion=objects.reduceRight(union);//{x:1,y:2,z:3,a:3}
/书中p130页和p31页关于union和extend的设计是这样的/
function extend(o,p){
for(prop in p){
o[prop]=p[prop];
}
return o;
}

function union(o,p){return extend(extend({},o),p);}
/* 我的出来的结果和书中的出来的leftunion和rightunion的值正好是相反的，
书上也讲到，union()函数在碰到两个对象有同名属性时，使用第一个参数的属性值，
按照这个说法确实和结果相符，但是验证结果是他给出的union函数使用的extend()
使用第二个参数作为的属性值进行合并的，亲能帮我看看是我哪里错了吗？万分感谢，
我先去star一下您的项目啦 */

huyong007 · 2018-07-26T09:43:26Z

楼主您的设计中第一个使用for循环的设计中我在实验这样一个 var arr = [1, [2, [[9, 0], 3, [2, 3]]]];结果给出的并不符合语气，我认为应该是您在设计for循环这个函数的时候外层的i被第二次出现的数组中的初始化给重置了，如果我们把for循环中的var改为let整个就没有任何问题了。

xiaolb · 2018-09-01T08:57:47Z

楼主，有一个小疑问，就是方法1中将push变成concat为什么就得不到想要的结果了
// 方法 1
var arr = [1, [2, [3, 4]]];

console.log(flatten(arr))

zjp6049 · 2019-02-27T03:41:27Z

额几个月前看没觉得什么最近突然遇到扁平化才知道不用递归写出扁平化牛P了哈

Chan-Chun · 2019-03-27T07:36:51Z

最近ES10标准已经支持扁平化了！Array.flat()，以后也不用写这样的方法啦！
https://pawelgrzybek.com/whats-new-in-ecmascript-2019/#array-prototype-flat-array-prototype-flatmap-by-brian-terlson-michael-ficarra-and-mathias-bynens

goSunadeod · 2019-04-29T09:06:24Z

// 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output else { flatten(value, shallow, strict, output); idx = output.length; }
这个idx重置有作用吗。。。麻烦又大佬知道的能告知一下，谢谢

JSluowen · 2019-05-03T07:49:16Z

感觉又进步一点点了

tr2v · 2019-05-09T06:05:43Z

// 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output else { flatten(value, shallow, strict, output); idx = output.length; }
这个idx重置有作用吗。。。麻烦又大佬知道的能告知一下，谢谢

递归数组后，output会变啊，不变idx，后面再插入数组项不就变成替换以后的了吗，我不明白的是这里怎么不直接用push呢

goSunadeod · 2019-05-09T08:20:57Z

// 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output else { flatten(value, shallow, strict, output); idx = output.length; }
这个idx重置有作用吗。。。麻烦又大佬知道的能告知一下，谢谢

递归数组后，output会变啊，不变idx，后面再插入数组项不就变成替换以后的了吗，我不明白的是这里怎么不直接用push呢

递归时output会变，但不是函数里面会重新定义var idx = output.length 吗这和递归函数之后的那句代码idx = output.length; 并没有关系啊

tr2v · 2019-05-10T03:25:48Z

递归时output会变，但不是函数里面会重新定义var idx = output.length 吗这和递归函数之后的那句代码idx = output.length; 并没有关系啊

函数内的idx是最新的没错，但是外部的还是原来的，递归结束后肯定要再获取一下

wbc0301 · 2019-06-24T04:22:04Z

console.log([].concat(...arr)) 这里用到的是函数的 rest 参数，大佬说成是数组的扩展运算符了

NameWjp · 2019-07-10T06:29:24Z

关于 flatten = Function.apply.bind([].concat, [])的理解，想了半天总算理解了。。。
首先是bind函数改变了this指向，而apply函数内部正是通过this去拿的执行的函数（参考博主前面call和apply的实现，一开始不理解就在这。。），然后传递了了[]参数，故现在flatten函数实际执行的是[].concat，this指向是[]，还接受一个数组（apply的第二个参数）。

rongda · 2019-07-18T03:12:18Z

var arr1 = [1, 2, [3, 4]];
arr1.flat(Infinity)

liuestc · 2019-11-07T08:50:45Z

function flatten(input) {
  const stack = [...input];
  const res = [];
  while (stack.length) {
    // 使用 pop 从 stack 中取出并移除值
    const next = stack.pop();
    if (Array.isArray(next)) {
      // 使用 push 送回内层数组中的元素，不会改动原始输入 original input
      stack.push(...next);
    } else {
      res.push(next);
    }
  }
  // 使用 reverse 恢复原数组的顺序
  return res.reverse();
}

leecode上看到的骚操作，感觉这个效率应该很高

guanxc9876 · 2019-11-27T02:59:24Z

output[idx++] = value[j++];这种出来的数组下标是不规律的，为啥不直接用push

Guard-233 · 2020-04-03T03:56:41Z

const flatten = (arr, shallow, strict) => {
  return arr.reduce((now, next) => {
    if (!shallow) {
      next = Array.isArray(next) ? flatten(next, shallow, strict) : next
    }
    if (strict && !Array.isArray(next)) {
      next = []
    }
    return now.concat(next)
  }, [])
}

稍微简化了一下

bikedawuwang · 2020-05-28T06:33:31Z

学习了

buquan · 2020-09-23T15:33:54Z

扁平化

数组的扁平化，就是将一个嵌套多层的数组 array (嵌套可以是任何层数)转换为只有一层的数组。

举个例子，假设有个名为 flatten 的函数可以做到数组扁平化，效果就会如下：
var arr = [1, [2, [3, 4]]];
console.log(flatten(arr)) // [1, 2, 3, 4]
知道了效果是什么样的了，我们可以去尝试着写这个 flatten 函数了

递归

我们最一开始能想到的莫过于循环数组元素，如果还是一个数组，就递归调用该方法：
// 方法 1
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        if (Array.isArray(arr[i])) {
            result = result.concat(flatten(arr[i]))
        }
        else {
            result.push(arr[i])
        }
    }
    return result;
}


console.log(flatten(arr))
toString

如果数组的元素都是数字，那么我们可以考虑使用 toString 方法，因为：
[1, [2, [3, 4]]].toString() // "1,2,3,4"
调用 toString 方法，返回了一个逗号分隔的扁平的字符串，这时候我们再 split，然后转成数字不就可以实现扁平化了吗？
// 方法2
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    return arr.toString().split(',').map(function(item){
        return +item
    })
}

console.log(flatten(arr))
然而这种方法使用的场景却非常有限，如果数组是 [1, '1', 2, '2'] 的话，这种方法就会产生错误的结果。

reduce

既然是对数组进行处理，最终返回一个值，我们就可以考虑使用 reduce 来简化代码：
// 方法3
var arr = [1, [2, [3, 4]]];

function flatten(arr) {
    return arr.reduce(function(prev, next){
        return prev.concat(Array.isArray(next) ? flatten(next) : next)
    }, [])
}

console.log(flatten(arr))
...

ES6 增加了扩展运算符，用于取出参数对象的所有可遍历属性，拷贝到当前对象之中：
var arr = [1, [2, [3, 4]]];
console.log([].concat(...arr)); // [1, 2, [3, 4]]
我们用这种方法只可以扁平一层，但是顺着这个方法一直思考，我们可以写出这样的方法：
// 方法4
var arr = [1, [2, [3, 4]]];

function flatten(arr) {

    while (arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr);
    }

    return arr;
}

console.log(flatten(arr))
undercore

那么如何写一个抽象的扁平函数，来方便我们的开发呢，所有又到了我们抄袭 underscore 的时候了~

在这里直接给出源码和注释，但是要注意，这里的 flatten 函数并不是最终的 _.flatten，为了方便多个 API 进行调用，这里对扁平进行了更多的配置。
/**
 * 数组扁平化
 * @param  {Array} input   要处理的数组
 * @param  {boolean} shallow 是否只扁平一层
 * @param  {boolean} strict  是否严格处理元素，下面有解释
 * @param  {Array} output  这是为了方便递归而传递的参数
 * 源码地址：https://github.com/jashkenas/underscore/blob/master/underscore.js#L528
 */
function flatten(input, shallow, strict, output) {

    // 递归使用的时候会用到output
    output = output || [];
    var idx = output.length;

    for (var i = 0, len = input.length; i < len; i++) {

        var value = input[i];
        // 如果是数组，就进行处理
        if (Array.isArray(value)) {
            // 如果是只扁平一层，遍历该数组，依此填入 output
            if (shallow) {
                var j = 0, length = value.length;
                while (j < length) output[idx++] = value[j++];
            }
            // 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output
            else {
                flatten(value, shallow, strict, output);
                idx = output.length;
            }
        }
        // 不是数组，根据 strict 的值判断是跳过不处理还是放入 output
        else if (!strict){
            output[idx++] = value;
        }
    }

    return output;

}
解释下 strict，在代码里我们可以看出，当遍历数组元素时，如果元素不是数组，就会对 strict 取反的结果进行判断，如果设置 strict 为 true，就会跳过不进行任何处理，这意味着可以过滤非数组的元素，举个例子：
var arr = [1, 2, [3, 4]];
console.log(flatten(arr, true, true)); // [3, 4]
那么设置 strict 到底有什么用呢？不急，我们先看下 shallow 和 strct 各种值对应的结果：

shallow true + strict false ：正常扁平一层

shallow false + strict false ：正常扁平所有层

shallow true + strict true ：去掉非数组元素

shallow false + strict true ：返回一个[]

我们看看 underscore 中哪些方法调用了 flatten 这个基本函数：

_.flatten

首先就是 _.flatten：
_.flatten = function(array, shallow) {
    return flatten(array, shallow, false);
};
在正常的扁平中，我们并不需要去掉非数组元素。

_.union

接下来是 _.union：

该函数传入多个数组，然后返回传入的数组的并集，

举个例子：
_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]
如果传入的参数并不是数组，就会将该参数跳过：
_.union([1, 2, 3], [101, 2, 1, 10], 4, 5);
=> [1, 2, 3, 101, 10]
为了实现这个效果，我们可以将传入的所有数组扁平化，然后去重，因为只能传入数组，这时候我们直接设置 strict 为 true，就可以跳过传入的非数组的元素。
// 关于 unique 可以查看《JavaScript专题之数组去重》[](https://github.com/mqyqingfeng/Blog/issues/27)
function unique(array) {
   return Array.from(new Set(array));
}

_.union = function() {
    return unique(flatten(arguments, true, true));
}
_.difference

是不是感觉折腾 strict 有点用处了，我们再看一个 _.difference：

语法为：

_.difference(array, *others)

效果是取出来自 array 数组，并且不存在于多个 other 数组的元素。跟 _.union 一样，都会排除掉不是数组的元素。

举个例子：
_.difference([1, 2, 3, 4, 5], [5, 2, 10], [4], 3);
=> [1, 3]
实现方法也很简单，扁平 others 的数组，筛选出 array 中不在扁平化数组中的值：
function difference(array, ...rest) {

    rest = flatten(rest, true, true);

    return array.filter(function(item){
        return rest.indexOf(item) === -1;
    })
}
注意，以上实现的细节并不是完全按照 underscore，具体细节的实现感兴趣可以查看源码。

专题系列

JavaScript专题系列目录地址：https://github.com/mqyqingfeng/Blog。

JavaScript专题系列预计写二十篇左右，主要研究日常开发中一些功能点的实现，比如防抖、节流、去重、类型判断、拷贝、最值、扁平、柯里、递归、乱序、排序等，特点是研(chao)究(xi) underscore 和 jQuery 的实现方式。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。

学习了

+1

Junezm · 2020-10-10T03:48:17Z

解构运算原理来打平数组

function* flatten(arr) {
    for (const item of arr) {
        if(Array.isArray(item)){
            yield* flatten(item)
        } else {
            yield item
        }
    }
}

var arr = [1, 2, [3, 4, [5, 6]]];
const flattened = [...flatten(arr)];

anjina · 2020-12-13T08:04:15Z

可以修改原数组的扁平化

// splice 修改原数组
function flattern_v3(arr, depth) {
  if(depth < 1) return arr;

  let i, len;
  for(i=0, len=arr.length; i < len; i++) {
    const item = arr[i];

    if(Array.isArray(item) && depth) {
      arr.splice(i, 1, ...item);
      len += item.length - 1;
      depth--;
    }
  }
}

bosens-China · 2021-02-23T06:51:54Z

_.difference([1, 2, 3, 4, 5], [5, 2, 10], [4], 3);
=> [1, 3]

这个示例错误，正确的是

_.difference([1, 2, 3, 4, 5], [5, 2, 10], [4], 3);
=> [1, 3, 10]

banli17 · 2021-04-05T06:27:05Z

@bosens-China
是[1,3]，这个是在 arr 去掉 ...rest 里有的

chloeeee72 · 2021-10-18T06:07:55Z

可以直接使用数组的.flat()方法，在括号内传入提取嵌套数组的结构深度就行了，MDN：Array.prototype.flat()

hotYan · 2022-04-07T09:35:22Z

使用 Generator 函数实现数组扁平化：

function* flat(arr){
    if(Array.isArray(arr)){
        for(const item of arr){
            yield* flat(item)
        }
    }else{
       yield arr
    }
}
// 测试
let flatted = [ ...flat([1,2,[3,4,[5,6]]]) ]
console.log(flatted) // [1,2,3,4,5,6]

RowlingJoe · 2022-09-29T06:12:26Z

arr.join(',').split(',')

rongda · 2022-10-11T08:41:38Z

你好，我已经收到你的来信！

mqyqingfeng added the 专题系列 label Jul 21, 2017

daochouwangu mentioned this issue Jul 21, 2017

2017-07-21 前端日报 daochouwangu/webfrontdaily#68

Open

mqyqingfeng mentioned this issue Aug 22, 2017

JavaScript专题之数组去重 #27

Open

mqyqingfeng mentioned this issue Sep 13, 2017

JavaScript专题之递归 #49

Open

mqyqingfeng mentioned this issue Oct 25, 2017

JavaScript专题系列二十篇正式完结！ #53

Open

Marinerer mentioned this issue Dec 27, 2018

【Javascript】知识点 Marinerer/store#1

Open

hidumou mentioned this issue May 29, 2019

文章收藏(JavaScript) hidumou/hidumou.github.io#2

Open

chenshuhong mentioned this issue Aug 23, 2019

JavaScript数组相关 chenshuhong/fullstack#6

Open

yangtao2o mentioned this issue Apr 3, 2020

JavaScript专题之数组扁平化 yangtao2o/learn#52

Open

swiftwind0405 mentioned this issue Oct 22, 2020

【JavaScript】数组拍平与数组去重 swiftwind0405/blog#68

Closed

Yilun-Sun mentioned this issue Jan 14, 2021

待分类 Yilun-Sun/front-end-progressive-note#9

Open

39 tasks

huitoutunao mentioned this issue Jul 11, 2021

数组扁平化 huitoutunao/Blog#11

Open

JavaScript专题之数组扁平化 #36

JavaScript专题之数组扁平化 #36

Comments

mqyqingfeng commented Jul 21, 2017 • edited Loading

扁平化

递归

toString

reduce

...

undercore

_.flatten

_.union

_.difference

专题系列

FrontToEnd commented Jul 24, 2017

kankk commented Jul 26, 2017

xiaobinwu commented Nov 5, 2017

sulingLiang commented Mar 2, 2018

HuangQiii commented Mar 2, 2018

mqyqingfeng commented Mar 8, 2018

swpuLeo commented Apr 11, 2018

mqyqingfeng commented Apr 13, 2018

thereisnowinter commented Apr 16, 2018

Tan90Qian commented Apr 17, 2018

Tan90Qian commented Apr 17, 2018

mqyqingfeng commented Apr 24, 2018 • edited Loading

mqyqingfeng commented Apr 24, 2018

Tan90Qian commented Apr 24, 2018

mqyqingfeng commented Apr 25, 2018

Tan90Qian commented Apr 25, 2018

mqyqingfeng commented Apr 25, 2018

Fiv5 commented Apr 26, 2018 via email

Fiv5 commented Apr 26, 2018 via email

Latube commented Apr 26, 2018 via email

mqyqingfeng commented Apr 26, 2018

delayk commented Apr 27, 2018

huyong007 commented Jul 26, 2018

huyong007 commented Jul 26, 2018

xiaolb commented Sep 1, 2018

zjp6049 commented Feb 27, 2019

Chan-Chun commented Mar 27, 2019

goSunadeod commented Apr 29, 2019

JSluowen commented May 3, 2019

tr2v commented May 9, 2019

goSunadeod commented May 9, 2019 • edited Loading

tr2v commented May 10, 2019 • edited Loading

wbc0301 commented Jun 24, 2019

NameWjp commented Jul 10, 2019

rongda commented Jul 18, 2019

liuestc commented Nov 7, 2019

guanxc9876 commented Nov 27, 2019

Guard-233 commented Apr 3, 2020

bikedawuwang commented May 28, 2020

buquan commented Sep 23, 2020

扁平化

递归

toString

reduce

...

undercore

_.flatten

_.union

_.difference

专题系列

Junezm commented Oct 10, 2020 • edited Loading

anjina commented Dec 13, 2020

bosens-China commented Feb 23, 2021

banli17 commented Apr 5, 2021 • edited Loading

chloeeee72 commented Oct 18, 2021 • edited Loading

hotYan commented Apr 7, 2022

RowlingJoe commented Sep 29, 2022

rongda commented Oct 11, 2022 via email

mqyqingfeng commented Jul 21, 2017 •

edited

Loading

mqyqingfeng commented Apr 24, 2018 •

edited

Loading

goSunadeod commented May 9, 2019 •

edited

Loading

tr2v commented May 10, 2019 •

edited

Loading

Junezm commented Oct 10, 2020 •

edited

Loading

banli17 commented Apr 5, 2021 •

edited

Loading

chloeeee72 commented Oct 18, 2021 •

edited

Loading