特点
    flat 扁平化 多维数组 -> 一维数组 ES2019

    1. 返回一个新的数组。将二维数组转成一维数组(默认什么参数都不传)。
    2. 默认情况下 参数为n 向数组内部深入n层
    3. flat 默认情况下是浅扁平化
    4. 多维数组扁平化
    5. 参数类型特点
      1. 负数 不做任何操作 返回一个新数组。 ```javascript // Array.prototype.flat ES 2019 // flat 扁平化 多维数组 ->一维数组 var arr = [1, 2, 3, 4, [5, 6]];

    // 1. 返回一个新数组。将二维数组转成一维数组 const newArr = arr.flat(); console.log(newArr === arr);

    // 2. 默认情况下 参数1 向数组内部深入1层

    const arr = [0, 1, [2, 3, 4, [5], 6], 7]; // 参数: 结构深度,默认为1, 向数组内部深入两层 const newArr = arr.flat(2); // 3. flat 默认情况下是浅扁平化

    // 4. 多维数组 扁平化 const arr = [1, [2, [3, [4, [5, [6, [7, 8]]], [9] ]], 10]]; console.log(arr.flat(Infinity));

    // 5. 填写负数 不做任何扁平化处理 // 字符串 不做任何处理 // 数字字符串 -> Number ->数字类型 // 数字必须要从 1-> Infinity // boolean 类型 -> Number -> 0|1 console.log(arr.flat(-2)); console.log(arr.flat(“a”)); console.log(arr.flat(“2”));

    // 6. flat会剔除所有数组空隙empty const arr = [1, , 2, , 3, [4, , , 5, , , 6, , 7, [8, 9]]]; console.log(arr.flat(Infinity));

    var a = 1, b = [2, 3]; //concat 是可以放入多个任意类型的元素 const newArr = b.concat(a);

    // 浅扁平化 // reduce 实现

    function shallowFlat(arr) { arr.reduce(function (prev, cur) { return prev.concat(cur); }, []); }

    function shallowFlat(arr) { return [].concat(…arr); }

    // 深度扁平化 // reduce+concat 实现

    Array.prototype.deepFlat = function () { var arr = Object(this), deep = arguments[0] != Infinity ? arguments[0] >>> 0 : Infinity; return deep > 0 ? arr.reduce(function (prev, cur) { return prev.concat(Array.isArray(cur) ? cur.deepFlat() : cur); }, []) : arr; };

    // forEach + isArray + push + 递归

    Array.prototype.deepFlat = function () { var arr = Object(this), deep = arguments[0] != Infinity ? arguments[0] >>> 0 : Infinity, res = []; (function (arr, deep) { arr.forEach(function (value, idx, arr) { if (Array.isArray(value) && deep > 0) { (value, deep—); } else { res.push(value); } }); })(arr, deep); return res; };

    // for of + isArray + push + 去掉empty

    Array.prototype.deepFlat = function () { var arr = Object(this), deep = arguments[0] !== Infinity ? arguments[0] >>> 0 : Infinity, res = []; (function (arr, deep) { for (var value of arr) { if (Array.isArray(value) && deep > 0) { (value, deep—); } else { value !== void 0 ? res.push(value) : “”; } } })(arr, deep); return res; };

    // stack pop + push

    // [1,2,3,4,5]=>[5,1,2,3,4] Array.prototype.deepFlat = function () { var arr = this, stack = […arr], res = []; while (stack.length) { const popItem = stack.pop(); if (Array.isArray(popItem)) { stack.push(…popItem); } else { res.push(popItem); } } return res.reverse(); };

    // 纯递归 Array.prototype.deepFlat = function () { var arr = this, res = []; (function (arr) { arr.forEach(function (item) { if (Array.isArray(item)) { (item); } else { res.push(item); } }); })(arr); return res; }; ```