数组扁平化

ES6的flat方法

flat()方法将以指定的深度递归遍历数组，并将所有元素与遍历的子数组中的元素合并到一个新数组返回

array = [1,1,2,3,[1,2,3,[1,1,2,3]]

//flat参数代表的是需要展开几层，如果是Infinity的话，就是不管嵌套几层，全部都展开

console.log(array.flat())

使用正则

首先使用JSON.stringify把arr转为字符串

接着使用正则表达式的把[]去掉

然后再拼接数组括号转为数组对象

const arr = [1,[1,2],3,2]
const res = JSON.stringify(arr).replace(^[|\]/g,'')
const res2 = JSON.parse('[' + res + ']')
console.log(res2)

使用递归

递归，在数学和计算机，是指的是函数本身使用函数的情况，通俗的理解就是我调用我自己

const array = []
const fn = (arr)=>{
for (let i = 0;i<arr.length;i++){
    if(Array.isArray(arr[i])){
    fn(arr[i])
}
else{
array.push(arr[i])
}
}
}
fn(arr)
console.log(arr)

这里设置递归主要是因为，我们对一个数组里的元素进行不断的深入，直到它不是一个数组，就把他推进我们的数组里面，从而实现数组扁平化

使用reduce

reduce()方法用来给数组求和

concat（）方法可以用于连接两个或多个数组

concat()方法不会更改现有数组，而是返回一个新数组，其中包含已连接数组的值

const newArr = (arr)=>{
    return arr.reduce((pre,cur)=>{
            return pre.concat(Array.isArray(cur)?newArr(cur):cur)},[])
}
console.log(newArr(arr),"reduce方法")

这个方法其实我感觉和递归有点类似，就是如果数组里面的元素还是一个数组的话我们就在函数里面调用这个函数，不断的深挖下去，直到这个元素不是数组为止，就把他拼接到我们的先前空数组里来。（纯属个人理解，如果有错的话，希望大神多加指点）

下面是对reduce方法的简单说明

定义：对数组中的每个元素执行一次自定义的累加器，将其结果汇总为单个返回值

形式：array.reduce((t,v,i,a)=>{},initvalue)

参数

callback:回调函数（必选）

initvalue：初始值（可选）

回调函数的参数

total（t）：累计完成计算的返回值(必选)

value(t):当前元素(必选)

index(i):当前元素的索引（可选）

array（a）：当前元素所属的数组对象（可选）

过程：

以t作为累计结果的初始值，不设置t则以数组的第一个元素为初始值

开始遍历，使用累计器处理v，将v的映射结果累计到t上，结束此次循环，返回t

进入下一次循环，重复上述操作，直至数组最后一个元素

结束遍历，返回最终的t

reduce的应用很广泛

可以进行累加累乘，可以进行权重求和，可以代替reverse

代替map和filter

const arr = [0,1,2,3];
//代替map:[0,2,4,6]
const a = arr.map(v=>v*2);
const b = arr.reduce((t,v)=>[...t,v]:t,[]);

//代替filter:[2,3]
const c = arr.filter(v=>v>1);
const d = arr.reduce((t,v)=>v>1>?[...t,v]:t,[]);

//代替map和filter:[4,6]
const e = arr.map(v=>v*2).filter(v=>v>2);
const f = arr.reduce((t,v)=>v*2>2>?[...t,v*2]:t,[]);

还有太多太多，这里就不一一介绍了，免得跑题了

继续介绍数组扁平化还有那些方法了

使用栈的思想实现flat函数

const newArr = []
const stack = []concat(arr);//将数组元素拷贝到栈里面，如果直接复制会破坏原数组
//如果栈不为空
while(stack.length !==0)
{
    const val = stack.pop();//删除数组的最后一个元素
    if(Array.isArray(val)){
    stack.push(...val)
    //如果是数组，我们就再次进栈，并且展开了一层
    }
    else{
    newArr.unshift(val);//如果不是数组，则把他放到结果数组里面
    }
}
return newArr