精华内容
下载资源
问答
  • flat方法

    2021-04-14 13:46:36
    flat()方法创建一个新数组,其中所有子数组元素都以递归方式连接到该数组中,直到达到指定的深度为止 const arr1 = [1, 2, [3, 4, [5, 6]]]; arr1.flat(2); // [1, 2, 3, 4, 5, 6] const arr2 = [1, 2, [3, 4, [5, ...

    flat()方法创建一个新数组,其中所有子数组元素都以递归方式连接到该数组中,直到达到指定的深度为止

    const arr1 = [1, 2, [3, 4, [5, 6]]];
    arr1.flat(2);
    // [1, 2, 3, 4, 5, 6]
    
    const arr2 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
    arr2.flat(Infinity);
    // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    
    展开全文
  • js中数组flat方法的使用和实现 定义 flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 语法 var newArray = arr.flat([depth]) 参数 depth 可选 指定要...

    js中数组flat方法的使用和实现

    定义

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

    语法

    var newArray = arr.flat([depth])

    参数

    depth 可选

    指定要提取嵌套数组的深度,默认值为 1。

    返回值

    一个包含将数组与子数组中所有元素的新数组。(就是扁平化后的每一项重新组成的数组,所以不会改变原数组。)

    使用示例

    扁平化数组,不传递参数的时候默认为一层

    let arr = [1,2,[3,[4,[5]]]]
    const reasut = arr.flat()
    console.log(reasut)
    // [1, 2, 3, [4,[5]]]
    

    设置扁平化的深度

    let arr = [1,2,[3,[4,[5]]]]
    const reasut2 = arr.flat(3)
    console.log(reasut2)
    // [1, 2, 3, 4, 5]
    

    当传入Infinity时,相当于扁平化最深层次的数组

    let arr = [1,2,[3,[4,[5]]]]
    const reasut3 = arr.flat(Infinity)
    console.log(reasut3)
    // [1, 2, 3, 4, 5]
    

    当数组里面有空项的时候,会过滤掉空值

    const arr2 = [1, , 2, [3]]
    const reasut4 = arr2.flat()
    console.log(reasut4)
    // [1, 2, 3]
    

    方法实现

    1、当只扁平化一层的时候

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list) {
      return list.reduce((pre, item) => {
        return pre.concat(item)
      }, [])
    }
    console.log(getFlatArr(arr5))
    // [1,2,3,[4,5],6,[7],8]
    

    上述代码使用reduce方法和concat方法组合,实现只展平一层数组的方法。还可以使用foreach和push方法如:

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    
    function getFlatArr (list) {
      let result = []
      list.forEach(element => {
        if (Array.isArray(element)) {
          result.push(...element)
        } else {
          result.push(element)
        }
      })
      return result
    }
    console.log(getFlatArr(arr5))
    // [1,2,3,[4,5],6,[7],8]
    

    上述代码采用foreach方法对数组的每一项循环,并使用isArray方法判断是不是数组将当前项push进result中,最后返回result。

    2、当数组展平的层数为最大层时

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list) {
      return list.reduce((pre, item) => pre.concat(Array.isArray(item)? getFlatArr(item): item), [])
    }
    console.log(getFlatArr(arr5))
    // [1, 2, 3, 4, 5, 6, 7, 8]
    

    上述代码使用数组的reduce方法和递归的形式实现,当reduce方法循环到数组的每一项时都去判断当前项是不是新的数组,是的话就使用递归去吧里面的每一项逐层剥离出来,最后进行合并,不是数组的话,就直接将当前项合并到数组中。还可以使用foreach方法+递归的方式进行实现,如:

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list) {
      const result = []
      ;(function flat(list) {
        // forEach 自动去除数组空位
        list.forEach(item => {
          // 判断是不是数组
          if (Array.isArray(item)) {
            // 进行数组递归
            flat(item)
          } else {
            result.push(item)
          }
        })
      })(list)
      return result
    }
    console.log(getFlatArr(arr5))
    // [1, 2, 3, 4, 5, 6, 7, 8]
    

    上述代码创建一个新的数组,使用foreach方法循环原始数组的每一项,然后判断当前项是否是一个数组是的话就递归,不是的话就将当前项push进新创建的数组,最后返回创建的数组。还可以使用堆栈的概念来实现,如:

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list) {
      const arrList = JSON.parse(JSON.stringify(list))
      const result = []
      while (arrList.length) {
        // 弹出堆栈中的数据
        let arr = arrList.shift()
        if (Array.isArray(arr)) arrList.unshift(...arr)
        else result.push(arr)
      }
      return result
    }
    
    console.log(getFlatArr(arr5))
    // [1, 2, 3, 4, 5, 6, 7, 8]
    

    上述代码使用堆栈概念存储数据,使用while语句进行循环弹出堆栈中的数据,弹出的数据如果不是数组类型的话就push进创建的新数组中,否则的话就将当前项解构后在一次存储进堆栈中,重复上述操作直到堆栈中的数据被清空,最后返回创建的数组。

    3、数组扁平化使用参数控制扁平的深度

    可以使用reduce方法和递归来实现如:

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list, deepNum = 1) {
      return deepNum > 0? list.reduce((pre, item) => {
        return pre.concat(Array.isArray(item)? getFlatArr(item, deepNum - 1): item)
      }, []): list.slice()
    }
    
    console.log(getFlatArr(arr5))
    // [1,2,3,[4,5], 6,[7], 8]
    
    console.log(getFlatArr(arr5, 3))
    // [1, 2, 3, 4, 5, 6, 7, 8]
    

    上述代码使用reduce方法,将循环的当前项展开成一个数组,然后通过传入的deepNum参数来控制展开的深度,当deepNum小于1的时候就返回原数组的一个浅拷贝,否则就根据deepNum的大小来展开对应深度的数组。还可以使用foreach方法+递归的形式来实现,如:

    const arr5 = [1,2,[3,[4,5]], [6,[7]], 8]
    function getFlatArr (list, deepNum = 1) {
      const result = []
      ;(function flat(list, deepNum) {
        list.forEach(element => {
          // 判断当前元素是否为数组并控制递归的深度
          if (Array.isArray(element) && deepNum > 0) flat(element, deepNum - 1)
          else result.push(element)
        })
      })(list, deepNum)
      return result
    }
    
    console.log(getFlatArr(arr5))
    // [1,2,3,[4,5], 6,[7], 8]
    
    console.log(getFlatArr(arr5, 3))
    // [1, 2, 3, 4, 5, 6, 7, 8]
    

    上述代码,首先创建一个新的数组result,然后使用自调用函数,传入原数组和深度大小,使用foreach进行循环,然后判断循环的当前项是否为数组,并且递归的深度的大小大于0,是的话就继续递归当前数组,深度减去1。否则的话就将当前元素push进新创建的数组result中,就是通过这样循环的方法,最后将原来数组中的每一项根据传入的深度大小都push进了一开始创建的新数组result中,最后返回数组result即可。

    展开全文
  • flat方法的简单实现

    2021-02-24 15:48:24
    记录一下实现flat方法的过程 flat实现的方式有很多种,这里只是记录一下其中的2种思路。 Array.prototype.flat()方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组...

    记录一下实现flat方法的过程

    flat实现的方式有很多种,这里只是记录一下其中的2种思路。

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

    递归实现

     function flat(arr, depth) {
        if (depth == undefined) {
            depth = 1;
        };
        if (depth > 0) {
            return arr.reduce((total, item) => {
                return total.concat(Array.isArray(item) ? flat(item, depth - 1) : item)
            }, []);
        } else {
            return arr;
        };
    };
    // const flatArr = flat([1,2,3,[4,[5,[6]]]], 1);
    // console.log(flatArr); // [1, 2, 3, 4, Array(2)]
    

    不使用递归

    function flat(arr = [], depth) {
        if (depth == undefined) {
            depth = 1;
        };
        while(arr.some(item => (Array.isArray(item) && depth > 0))) {
            // ...arr每次只能展开一层
            arr = [].concat(...arr);
            // 限制层级
            depth--; 
        }
        return arr;
    };
    // const flatArr = flat([1,2,3,[4,[5,[6]]]], Infinity)
    // console.log(flatArr) // [1, 2, 3, 4, 5, 6]
    
    展开全文
  • 在一些大厂的面试中,flat方法的实现往往是一道比较基础的面试题,通常出现在笔试或者第一轮面试当中,主要考察基本的手写代码的能力。首先我们先来回顾一下flat方法概念。 一、概念 1.数组扁平化方法 Array....

    在这里插入图片描述

    本次推文将会带领大家通过手写来达到模拟数组拍平(扁平化) flat 方法实现。

    在一些大厂的面试中,flat方法的实现往往是一道比较基础的面试题,通常出现在笔试或者第一轮面试当中,主要考察基本的手写代码的能力。首先我们先来回顾一下flat方法概念。

    一、概念

    1.数组扁平化方法 Array.prototype.flat() 也叫数组拍平、数组拉平、数组降维。
    const arr = [1,[2,3],[4,[5,[6]],7]];
    
    // 不传参数时,默认“拉平”一层
    arr.flat() 
    // [1,2,3,4,[5,[6]],7];
    
    // 传入一个整数参数,整数即“拉平”的层数
    arr.flat(2) 
    // [1,2,3,4,5,[6],7];
    
    // Infinity 关键字作为参数时,无论多少层嵌套,都会转为一维数组
    arr.flat(Infinity);
    // [1,2,3,4,5,6,7];
    
    // 传入 <=0 的整数将返回原数组,不“拉平”
    arr.flat(0);
    // [1,[2,3],[4,[5,[6]],7]]
    arr.flat(-6);
    // [1,[2,3],[4,[5,[6]],7]]
    
    // 如果原数组有空位,flat()方法会跳过空位
    [1,2,3,4,5,6,,].flat();
    // [1,2,3,4,5,6]
    
    2.Array.prototype.flat() 特性总结
    • Array.prototype.flat() 用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。
    • 不传参数时,默认“拉平”一层,可以传入一个整数,表示想要“拉平”的层数。
    • 传入 <=0 的整数将返回原数组,不“拉平”。
    • Infinity 关键字作为参数时,无论多少层嵌套,都会转为一维数组。
    • 如果原数组有空位,Array.prototype.flat() 会跳过空位。

    二、实现思路

    1.思路:

    实现一个有数组扁平化功能的 flat 函数,我们要做的就是在数组中找到是数组类型的元素,然后将他们展开。这就是实现数组拍平 flat 方法的关键思路。

    2.流程:
    • 第一要遍历数组的每一个元素;
    • 第二判断元素是否是数组;
    • 第三将数组的元素展开一层;
    3.遍历数组方案:
    • for 循环
    • for...of
    • for...in
    • forEach()
    • entries()
    • keys()
    • values()
    • reduce()
    • map()
    3.判断元素是数组方案:
    • instanceof
    • constructor
    • Object.prototype.toString
    • isArray
    4.将数组的元素展开一层方案:
    • 扩展运算符(…) + concat

    concat() 方法用于合并两个或多个数组,在拼接的过程中加上扩展运算符会展开一层数组。详细见下面的代码。

    • concat +apply

    主要是利用 apply 在绑定作用域时,传入的第二个参数是一个数组或者类数组对象,其中的数组元素将作为单独的参数传给 func 函数。也就是在调用 apply 函数的过程中,会将传入的数组一个一个的传入到要执行的函数中,也就是相当对数组进行了一层的展开。

    三、实现方法

    1.简单实现
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "前端收割机" }];
    // 通过concat方法加递归方法实现
    function myflat(arr){
        let res = []; // 存放扁平化数组
        arr.forEach(item =>{ // 遍历存入数组
            if(Array.isArray(item)){ // 判断当前元素是否为数组
                // callee 属性是 arguments 对象的一个成员,它表示对函数对象本身的引用
                res = res.concat(arguments.callee(item)); // 递归调用
            }else{
                res.push(item);
            }
        });
        return res;
    }
    
    myflat(arr);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "前端收割机" }];
    
    2.用 reduce 实现 flat 函数
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "前端收割机" }];
    
    // 首先使用 reduce 展开一层效果
    arr.reduce((pre,cur)=>pre.concat(cur),[]);
    // [1, 2, 3, 4, 1, 2, 3, [1, 2, 3, [1, 2, 3]], 5, "string", { name: "前端收割机" }];
    
    // 用 reduce 展开一层 + 递归调用
    const myflat = arr =>{
        return arr.reduce((pre,cur)=>{
            return pre.concat(Array.isArray(cur) ? myflat(cur) : cur);
        },[]);
    };
    
    myflat(arr);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "前端收割机" }];
    
    3.使用栈的思想实现 flat 函数
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "前端收割机" }];
    
    // 栈思想
    function myflat(arr){
        const res = [];
        const stack = [].concat(arr); // 将数组元素拷贝至栈,直接赋值会改变原数组
        while(stack.length !== 0){ // 如果栈不为空,则循环遍历
            const value = stack.pop(); // 弹出栈顶元素
            if(Array.isArray(val)){
                stack.push(...val); // 如果当前元素为数组,将其扩展后再入栈
            }else{
                res.unshift(val); // 如果当前元素不是数组,就将其取出来放入结果数组中
            }
        }
        return res;
    }
    
    myflat(arr);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "前端收割机" }];
    
    4.通过传入整数参数控制“拉平”层数
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "前端收割机" }];
    
    // 用 reduce + 递归调用
    function myflat(arr,num = 1){
        return num > 0 
            ? arr.reduce((res,cur) =>{
            pre.concat(Array.isArray(cur) ? myflat(cur,num-1):cur)
        	},[]) 
        	: arr.slice();
            
    }
    
    flat(arr, Infinity);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "前端收割机" }];
    
    5.实现在原型链上重写 flat 函数
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "前端收割机" }];
    
    Array.prototype.myFlat = function(num = 1) {
      if (!Number(num) || Number(num) < 0) {
        return this;
      }
      let arr = this.concat();    // 获得调用 myFlat 函数的数组
      while (num > 0) {           
        if (arr.some(x => Array.isArray(x))) {
          arr = [].concat.apply([], arr);	// 数组中还有数组元素的话并且 num > 0,继续展开一层数组 
        } else {
          break; // 数组中没有数组元素并且不管 num 是否依旧大于 0,停止循环。
        }
        num--;
      }
      return arr;
    };
    
    arr.myFlat(Infinity);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "前端收割机" }];
    
    6.考虑数组空位的情况

    由最开始我们总结的 flat 特性知道,flat 函数执行是会跳过空位的。ES5 大多数数组方法对空位的处理都会选择跳过空位包括:forEach(), filter(), reduce(), every()some() 都会跳过空位。

    // reduce + 递归调用
    Array.prototype.myFlat = function(num = 1) {
      if (!Number(num) || Number(num) < 0) {
        return this;
      }
      let arr = [].concat(this);
      return num > 0
        ? arr.reduce(
            (pre, cur) =>
              pre.concat(Array.isArray(cur) ? cur.myFlat(--num) : cur),
            []
          )
        : arr.slice();
    };
    const arr = [1, [3, 4], , ,];
    arr.myFlat()
    // [1, 3, 4]
    
    // foEach + 递归调用
    Array.prototype.myFlat = function(num = 1) {
      if (!Number(num) || Number(num) < 0) {
        return this;
      }
      let arr = [];
      this.forEach(item => {
        if (Array.isArray(item)) {
          arr = arr.concat(item.myFlat(--num));
        } else {
          arr.push(item);
        }
      });
      return arr;
    };
    const arr = [1, [3, 4], , ,];
    arr.myFlat()
    // [1, 3, 4]
    
    

    希望大家能在本篇推文中收获满满。求关注!!!

    参考链接:https://juejin.cn/post/6844904025993773063

    展开全文
  • Array.flat方法

    2021-11-29 16:12:59
    Array.flat方法 作用 用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。 语法 /** * @params { Number } num 需要将数组拉平的层数,默认是1 */ array.flat(num) 实例 [1, 2,...
  • 1.touch方法 既想传参,又想用event @touchend=“gotouched(item, $event)” 调用时gotouched(item, event){ //event.target真的很有用 event.target.className(’’)//... } 2.flat方法 本来用flat方法给数组进行扁平
  • 当时我遇到的时候还不了解flat这个神奇的方法,用了最传统的解决方法进行解决。 const flatten = arr => arr.toString().split(’,’).map(item => +item); const arr = [1, 2, [3, 4, [5, 6]]]; console.log...
  • 手动实现一个flat方法

    2021-09-04 23:29:33
    最近看 vue 源码的时候,看到了 normalizeArrayChildren 里面对数组的打平操作,感觉很不错就把它单独抽离出来,做了小改动 function myFlat(array, deep) { const res = []; let i, c; for (i = 0;...
  • 数组排序与flat方法

    2021-01-06 10:24:52
    } } let hd = lessons.sort(order('a', 'desc')) flat方法 Array.prototype.flat()用于将嵌套的数组“拉平”,变成一维数组。该方法返回一个新数组,对原数据没有影响。 [1, 2, [3, 4]].flat() // [1, 2, 3, 4] ...
  • flat 是将数组扁平化的一种方法。 比如:我们有一个数组: let arr = [ [1,2,3], [4,5,6], [6,7, [3,4]] ] 现在需要将数组元素转化成 [ 1, 2, 3, 4, 5, 6, 6, 7, [ 3, 4 ] ] (浅扁平)或 [ 1, 2, 3, 4, 5, 6, 6, 7,...
  • 需求:多维数组=>一维数组 1 2 let ary = [1, [2, [3, [4, 5]]], 6];... arr_flat = arr.flat(Infinity); 第一种处理 1 ary = str.replace(/(\[\]))/g, '').split(',');
  • flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 长话短说,就是按照flat里面的参数对Array做一个去括号的操作,默认去一层。 下面就简单实现下 Array...
  • 手写flat() 方法并挂到Array原型上。 ```javascript Array.prototype.flat = function(count) { let c = count || 1; let len = this.length; let exe = []; if (this.length == 0) return this; while (c--)...
  • // 想摊平多层就将flat()方法的参数写出一个整数,表示想要拉平的层数 [1,2,[3,[4,5]]].flat(2) //[1,2,3,4,5] // 不管多少层嵌套数组, 都只想转成一维数组, 可以用infinity关键字作为参数 [1,[2,3,[4]]].flat(i
  • flat方法的用法如下所示: const newArray = arr.flat([depth]) 小试牛刀 const arr = [1, 2, [3, 4, [5, 6]]]; console.log(arr.flat(1)); // [ 1, 2, 3, 4, [ 5, 6 ] ] console.log(arr....
  • 方法1:reduce,遍历数组每一项,若值为数组则递归遍历,否则concat 代码如下 let arr = [1, [2, 3, [4, 5], 6]]; //方法1:reduce,遍历数组每一项,若值为数组则递归遍历,否则concat function flatten(arr)...
  • JS数组扁平化(flat)

    2020-12-22 08:26:45
    需求:多维数组=>一维数组let ary = [1, [2, [3, [4, 5]]], 6...第0种处理:直接的调用arr_flat = arr.flat(Infinity);第一种处理ary = str.replace(/(\[\]))/g, '').split(',');第二种处理str = str.replace(/(\[\...
  • 使用flat()方法实现数组...下面为flat方法使用的案例: const testArr=["a",["b","c"],["d",["e",["f"]]],"g"]; //flat不传参时,默认扁平化一层 console.log(testArr.flat()); // [ 'a', 'b', 'c', 'd', [ 'e', [ 'f'
  • 注意:flat和flatMap方法为ES2019(ES10)方法,目前还未在所有浏览器完全兼容。 第2种处理 str.replace(/(\[\]))/g, '').split(','); 第3种处理 str = str.replace(/(\[\]))/g, '');str = '[' + str + ']';var ary =...
  • 多维数组降维 flat()方法的作用和用法 一、作用 flat()方法用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。 二、用法 示例:let arr = [1,2,3,[4,5,[6,7],8],9] arr.flat() ...
  • 在学习数组扁平化之前,先了解一下reduce()方法~~ QoQ reduce()方法及高级技巧 reduce()方法接收一个函数作为累加器,数组中的每个值(从左向右)开始缩减,最终计算为一个值。注意:reduce()方法不能对空数组执行回...
  • JS手写flat函数

    2021-12-15 21:17:18
    flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 const arr = [1, 2, [3, 4, [5, 6, [7]]], 8]; console.log(arr.flat(Infinity)); //[1,2,3,4,5,6,7,...
  • flat()将多维数组转化为低维数组 const arr = [1,2,3,4,[5,6]] console.log(arr.flat()) //[1, 2, 3, 4, 5, 6] const arr1 = [1,2,3,4,[5,6,[7,8,9]]] console.log(arr1.flat()) //[1, 2, 3, 4, 5, 6, [7,8,9]] //...
  • es6原生的方法 链接: es6中的flat let arr = [1, 2, [3, 4]].flat() console.log(arr) //[ 1, 2, 3, 4 ] //flat默认只展平一层 console.log([1, 2, [3, 4,[5,6]]].flat()) //[ 1, 2, 3, 4, [ 5, 6 ] ] //展平多层...
  • 例子 includes 注意,includes立面采用的时全等运算符 flat flat好像是es10出的特性,用于拉平数组,接受一个参数,不传默认1,表示拉平的层数 实现 原理就是利用递归,判断层数,一层一层进去,层数i依次减去1,当...
  • 数组 flat

    2021-04-01 15:46:03
    注:数组拍平方法Array.prototype.flat()也叫数组扁平化、数组拉平、数组降维。 本文统一叫:数组拍平 const animals = ["????", ["????", "????"], ["????", ["????", ["????"]], "????"]]; // 不传参数时,默认...
  • 代码地址:https://github.com/LeeSureman/Flat-Lattice-Transformer 文章目录背景介绍模型设计将格子转换为平坦结构对于区间的相关位置编码实验结果 Character-word lattice结构对于解决中文NER问题是有效的,然而...
  • 文章目录MDN Web文档 Array.prototype.flat() 扁平化数组的四个替代方案代码解析什么是扁平化标准方法替代方案后言 注:本文为MDN标准Web文档中例子的解释,代码来自MDNArray.prototype.flat()。 什么是扁平化 将某...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,823
精华内容 18,729
关键字:

flat方法