1.一维数组转二维数组

[1, 2, 3, 4, 5, 6, 7, 8] 实现效果 [[1, 2, 3, 4], [5, 6, 7, 8]]

1.1 slice截取

  1.         function fn(arr, num) {
  2.             let newArr = []
  3.             const total = Math.ceil(arr.length / num)
  4.             console.log(total);
  5.             for (let i = 0; i < total; i++) {
  6.                 a = arr.slice(i * num, (i + 1) * num)
  7.                 newArr.push(a)
  8.             }
  9.             return newArr
  10.         }
  11.         let arr = [1, 2, 3, 4, 5, 6, 7, 8]
  12.         console.log(fn(arr, 4));

newArr 用来接收转换的二维数组
total 代表外层数组需要包含几个内层数组
slice进行分隔 第一个参数 开始截取的索引 第二个参数 结束的索引
把每次截取的数组添加到newArr里

1.2.splice

先来学习一下深拷贝高级的代码

  1. JSON.parse(JSON.stringify(obj||arr))
  1.         function fn(arr, num) {
  2.             let newArr = []
  3.             let copyArr = JSON.parse(JSON.stringify(arr))
  4.             const total = Math.ceil(arr.length / num)
  5.             console.log(total);
  6.             for (let i = 0; i < total; i++) {
  7.                 a = copyArr.splice(0, num)
  8.                 newArr.push(a)
  9.             }
  10.             return newArr
  11.         }
  12.         let arr = [1, 2, 3, 4, 5, 6, 7, 8]
  13.         console.log(fn(arr, 4));

思路大致一致 只不过这次拿到的是splice的返回值
注意直接splice拿到返回值 会改变原数组 注意哦 ！！ 相当于把原数组全部删除了，任何情况下最好都不要删除原数组，因为原数组可能还有别的地方要用到哈！

1.3. 遍历判断

  1.    function fn(arr, num) {
  2.             let newArr = []
  3.             arr.forEach((it,idx) => {
  4.                 const total = Math.floor(idx / num) //判断当前在第几个数组内
  5.                 if(!(newArr[total])){ //判断当前是否有数组
  6.                     newArr[total]=[]  //如果没有赋值一个空
  7.                 }
  8.                 newArr[total].push(it) // 并且把当前对应的索引里面进行添加
  9.             });
  10.             return newArr
  11.         }
  12.         let arr = [1, 2, 3, 4, 5, 6, 7, 8]
  13.         console.log(fn(arr, 4));

2.二维数组转一维数组

1. flat()

语法：var newArray = arr.flat([depth]) depth(深度)：指定要提取嵌套数组的结构深度，默认值为 1。

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

  1.     const arr = [1,2,3,4,[5,6,7]]
  2.     console.log(arr.flat()); //[1, 2, 3, 4, 5, 6, 7]

不写参数 默认值为1 可扁平化一层 扁平最外层

  1.         const arr1 = [1,2,3,4,[5,[6,7]]]
  2.         console.log(arr1.flat()); //[1, 2, 3, 4, 5, [5,6]]

指定扁平化次数

  1.         const arr2 = [1,2,3,4,[5,[6,7]]]
  2.         console.log(arr2.flat(2)); //[1, 2, 3, 4, 5, 6, 7]

一步到位之转换一维数组 无论几维数组 都变成一维数组

  1.         const arr3 = [1,[2,[3,[4,[5]]]]]
  2.         console.log(arr3.flat(Infinity))

2. reduce+concat

concat：用来拼接两个或多个数组 不会改变原数组，返回一个新数组
reduce 累加器 参数callback callback参数：acc,val,idx,arr acc:作为累加器，每次拿到上一次的返回值，val数组的每一项，idx：索引 默认从0，arr调用reduce 的原数组

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         console.log(arr.reduce((acc,val)=>acc.concat(val),[])); //[1, 2, 3, 4, 5, 6, 7]

通过[ ] 每次都通过reduce() 拼接数组中的每一项 返回一个新的数组

3. [ ].concat

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         console.log([].concat(...arr));

…arr 1,2,3,4,[5,6,7]
[ ].concat(…arr) 1,2,3,4,[5,6,7] 拼接成一个数组

4. concat.apply

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         console.log([].concat.apply([], arr));

apply的第二个参数要求是一个数组 你可以理解为 先将1进行合并成一个数组 在将2 合并成一个数组 以此类推

5. toString + split （字符串或数值）

split 将字符串类型利用分隔符分隔 转换成数组

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         const str = arr.toString() //1,2,3,4,5,6,7  (字符串类型)
  3.         console.log(str.split(',')); //["1", "2", "3", "4", "5", "6", "7"]

简化

  1. arr.toString().split(',')

注意利用 split转换后 每一项变成了字符串类型 如果你只需要字符串类型 到这步已经完成了
如果你只需要数值类型 可用map 进行对每一项Number转换 字符串类型会转成NaN

  1.         console.log(arr.toString().split(',').map(Number)); //[1, 2, 3, 4, 5, 6, 7]

6. 遍历判断

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         const falt = []
  3.         arr.forEach(it => {
  4.             if(Array.isArray(it)){
  5.                 falt.push(...it)
  6.             }else {
  7.                 falt.push(it)
  8.             }
  9.         })
  10.         console.log(falt);

遍历数组中的每一项 如果数组中还有数组 就进行展开（…ES6新语法）添加到数组中 如果没有 就直接添加到数组中
复习判断是否为数组

Array.isArray(数组) 数组 instanceof Array 数组.constructor===Array

中间的判断可简化为三元

  1.         const arr = [1, 2, 3, 4, [5, 6, 7]]
  2.         const falt = []
  3.         arr.forEach(it => Array.isArray(it) ? falt.push(...it) : falt.push(it))
  4.         console.log(falt);

7.多维数组转一维数组

  1.         const arr = [1, 2, 3, 4, [5, [6, 7]]]
  3.         function recursion(arr) {
  4.            const falt = []
  5.            arr.forEach((it, idx) =>  Array.isArray(arr[idx]) ? falt.push(...recursion(arr[idx])) : falt.push(arr[idx]))
  6.             return falt
  7.         }
  8.         console.log(recursion(arr));