精华内容
下载资源
问答
  • js代码-数组flat函数实现
  • 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 是将数组扁平化的一种方法。 比如:我们有一个数组: 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,...

    Flat

    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, 3, 4] (深扁平)

    • 浅扁平:只能扁平化二级数组
    • 深扁平:可以扁平多维数组

    浅扁平实现

    第一种:自带方法

    function myFlat(arr) {
      arr = Array.isArray(arr) ? arr : Array.from(arr)
      return arr.flat()
    }
    

    第二种:reduce 累加

    function myFlatReduce(arr) {
      return arr.reduce((total, current) => total.concat(current), [])
    }
    

    深扁平

    第一种:经典递归回调法 (参考第三种 Generator 法)

    function myFlatRecursion(arr) {
    	let result = []
    	for(const item of arr) {
    		if (Array.isArray(item)) {
    			result = result.concat(myFlatRecursion) // concat 合并并返回新数组,不会修改原数组
    		} else {
    			result.push(item)
    		}
    	}
    	return result
    }
    

    第二种:字符串

    // 缺点:扁平化后的每一项都是字符串
    function myFlatStr(arr) {
      return arr.toString().split(',')
    }
    

    第三种:Generator 法

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

    待续

    展开全文
  • 数组的展平,主要是指的是数组嵌套数组转为一维数组,总结了一下几种方法 es6原生的方法 链接: es6中的flat let arr = [1, 2, [3, 4]].flat() console.log(arr) //[ 1, 2, 3, 4 ] //flat默认只展平一层 console....

    数组的展平,主要是指的是数组嵌套数组转为一维数组,总结了一下几种方法

    1. 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 ] ]
    //展平多层需要传递参数Infinity
    console.log([1, 2, [3, 4,[5,6]]].flat())
    //[ 1, 2, 3, 4, 5, 6 ]
    
    1. js原生的方法
    //[ 1, 2, 3, 4, 5, 6 ]
    console.log(arr.toString().split(',').map(item => +item))
    //可以展平任意层级的array
    
    1. 递归
    let result = []
    let arr = [1, 2, [3, 4,[5,6]]]
    function flatFn(arr){
    	arr.forEach(item => {
    		if(Array.isArray(item)){
    			flatFn(item)
    		}else{
    			result.push(item)
    		}
    	})
    	return result
    }
    console.log(flatFn(arr)) //[ 1, 2, 3, 4, 5, 6 ]
    
    展开全文
  • 需求:多维数组=>一维数组 let ary = [1, [2, [3, [4, 5]]], 6]; let str = JSON.stringify(ary); 第0种处理:直接的调用 arr_flat = arr.flat(Infinity); 第一种处理 ary = str.replace(/(\[\]))/g, '').split...
  • 数组 flat

    2021-04-01 15:46:03
    注:数组拍平方法Array.prototype.flat()也叫数组扁平化、数组拉平、数组降维。 本文统一叫:数组拍平 const animals = ["????", ["????", "????"], ["????", ["????", ["????"]], "????"]]; // 不传参数时,默认...

    一段代码总结 Array.prototype.flat() 特性

    注:数组拍平方法  Array.prototype.flat() 也叫数组扁平化、数组拉平、数组降维。 本文统一叫:数组拍平
    const animals = ["🐷", ["🐶", "🐂"], ["🐎", ["🐑", ["🐲"]], "🐛"]];
    
    // 不传参数时,默认“拉平”一层
    animals.flat();
    // ["🐷", "🐶", "🐂", "🐎", ["🐑", ["🐲"]], "🐛"]
    
    // 传入一个整数参数,整数即“拉平”的层数
    animals.flat(2);
    // ["🐷", "🐶", "🐂", "🐎", "🐑", ["🐲"], "🐛"]
    
    // Infinity 关键字作为参数时,无论多少层嵌套,都会转为一维数组
    animals.flat(Infinity);
    // ["🐷", "🐶", "🐂", "🐎", "🐑", "🐲", "🐛"]
    
    // 传入 <=0 的整数将返回原数组,不“拉平”
    animals.flat(0);
    animals.flat(-10);
    // ["🐷", ["🐶", "🐂"], ["🐎", ["🐑", ["🐲"]], "🐛"]];
    
    // 如果原数组有空位,flat()方法会跳过空位。
    ["🐷", "🐶", "🐂", "🐎",,].flat();
    // ["🐷", "🐶", "🐂", "🐎"]
    

    Array.prototype.flat() 特性总结

    • Array.prototype.flat() 用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。
    • 不传参数时,默认“拉平”一层,可以传入一个整数,表示想要“拉平”的层数。
    • 传入 <=0 的整数将返回原数组,不“拉平”
    • Infinity 关键字作为参数时,无论多少层嵌套,都会转为一维数组
    • 如果原数组有空位,Array.prototype.flat() 会跳过空位。

    面试官 N 连问

    第一问:实现一个简单的数组拍平 flat 函数

    首先,我们将花一点篇幅来探讨如何实现一个简单的数组拍平 flat 函数,详细介绍多种实现的方案,然后再尝试接住面试官的连环追问。

    实现思路

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

    有了思路,我们就需要解决实现这个思路需要克服的困难:

    • 第一个要解决的就是遍历数组的每一个元素;
    • 第二个要解决的就是判断元素是否是数组;
    • 第三个要解决的就是将数组的元素展开一层;

    遍历数组的方案

    遍历数组并取得数组元素的方法非常之多,包括且不限于下面几种

    • for 循环
    • for...of
    • for...in
    • forEach()
    • entries()
    • keys()
    • values()
    • reduce()
    • map()
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }];
    // 遍历数组的方法有太多,本文只枚举常用的几种
    // for 循环
    for (let i = 0; i < arr.length; i++) {
      console.log(arr[i]);
    }
    // for...of
    for (let value of arr) {
      console.log(value);
    }
    // for...in
    for (let i in arr) {
      console.log(arr[i]);
    }
    // forEach 循环
    arr.forEach(value => {
      console.log(value);
    });
    // entries()
    for (let [index, value] of arr.entries()) {
      console.log(value);
    }
    // keys()
    for (let index of arr.keys()) {
      console.log(arr[index]);
    }
    // values()
    for (let value of arr.values()) {
      console.log(value);
    }
    // reduce()
    arr.reduce((pre, cur) => {
      console.log(cur);
    }, []);
    // map()
    arr.map(value => console.log(value));

    只要是能够遍历数组取到数组中每一个元素的方法,都是一种可行的解决方案。

    判断元素是数组的方案

    • instanceof
    • constructor
    • Object.prototype.toString
    • isArray
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }];
    arr instanceof Array
    // true
    arr.constructor === Array
    // true
    Object.prototype.toString.call(arr) === '[object Array]'
    // true
    Array.isArray(arr)
    // true

    说明

    • instanceof 操作符是假定只有一种全局环境,如果网页中包含多个框架,多个全局环境,如果你从一个框架向另一个框架传入一个数组,那么传入的数组与在第二个框架中原生创建的数组分别具有各自不同的构造函数。(所以在这种情况下会不准确)
    • typeof 操作符对数组取类型将返回 object
    • 因为 constructor 可以被重写,所以不能确保一定是数组。

      const str = 'abc';
      str.constructor = Array;
      str.constructor === Array 
      // true

    将数组的元素展开一层的方案

    • 扩展运算符 + concat

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

    • concat + apply

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

    • toString + split

    不推荐使用 toString + split 方法,因为操作字符串是和危险的事情,在上一文章中我做了一个操作字符串的案例还被许多小伙伴们批评了。如果数组中的元素所有都是数字的话,toString + split 是可行的,并且是一步搞定。

    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }];
    // 扩展运算符 + concat
    [].concat(...arr)
    // [1, 2, 3, 4, 1, 2, 3, [1, 2, 3, [1, 2, 3]], 5, "string", { name: "弹铁蛋同学" }];
    
    // concat + apply
    [].concat.apply([], arr);
    // [1, 2, 3, 4, 1, 2, 3, [1, 2, 3, [1, 2, 3]], 5, "string", { name: "弹铁蛋同学" }];
    
    // toString  + split
    const arr2 =[1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]]]
    arr2.toString().split(',').map(v=>parseInt(v))
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3]

    总结完要解决的三大困难,那我们就可以非常轻松的实现一版数组拍平 flat 函数了。

    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }];
    // concat + 递归
    function flat(arr) {
      let arrResult = [];
      arr.forEach(item => {
        if (Array.isArray(item)) {
          arrResult = arrResult.concat(arguments.callee(item));   // 递归
          // 或者用扩展运算符
          // arrResult.push(...arguments.callee(item));
        } else {
          arrResult.push(item);
        }
      });
      return arrResult;
    }
    flat(arr)
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    到这里,恭喜你成功得到了面试官对你手撕代码能力的基本认可🎉。但是面试官往往会不止于此,将继续考察面试者的各种能力。

    第二问:用 reduce 实现 flat 函数

    我见过很多的面试官都很喜欢点名道姓的要面试者直接用 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 flat = arr => {
      return arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? flat(cur) : cur);
      }, []);
    };
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    第三问:使用栈的思想实现 flat 函数

    // 栈思想
    function flat(arr) {
      const result = []; 
      const stack = [].concat(arr);  // 将数组元素拷贝至栈,直接赋值会改变原数组
      //如果栈不为空,则循环遍历
      while (stack.length !== 0) {
        const val = stack.pop(); 
        if (Array.isArray(val)) {
          stack.push(...val); //如果是数组再次入栈,并且展开了一层
        } else {
          result.unshift(val); //如果不是数组就将其取出来放入结果数组中
        }
      }
      return result;
    }
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }]
    flat(arr)
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    第四问:通过传入整数参数控制“拉平”层数

    // reduce + 递归
    function flat(arr, num = 1) {
      return num > 0
        ? arr.reduce(
            (pre, cur) =>
              pre.concat(Array.isArray(cur) ? flat(cur, num - 1) : cur),
            []
          )
        : arr.slice();
    }
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }]
    flat(arr, Infinity);
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    第五问:使用 Generator 实现 flat 函数

    function* flat(arr, num) {
      if (num === undefined) num = 1;
      for (const item of arr) {
        if (Array.isArray(item) && num > 0) {   // num > 0
          yield* flat(item, num - 1);
        } else {
          yield item;
        }
      }
    }
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }]
    // 调用 Generator 函数后,该函数并不执行,返回的也不是函数运行结果,而是一个指向内部状态的指针对象。
    // 也就是遍历器对象(Iterator Object)。所以我们要用一次扩展运算符得到结果
    [...flat(arr, Infinity)]    
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    第六问:实现在原型链上重写 flat 函数

    Array.prototype.fakeFlat = function(num = 1) {
      if (!Number(num) || Number(num) < 0) {
        return this;
      }
      let arr = this.concat();    // 获得调用 fakeFlat 函数的数组
      while (num > 0) {           
        if (arr.some(x => Array.isArray(x))) {
          arr = [].concat.apply([], arr);    // 数组中还有数组元素的话并且 num > 0,继续展开一层数组 
        } else {
          break; // 数组中没有数组元素并且不管 num 是否依旧大于 0,停止循环。
        }
        num--;
      }
      return arr;
    };
    const arr = [1, 2, 3, 4, [1, 2, 3, [1, 2, 3, [1, 2, 3]]], 5, "string", { name: "弹铁蛋同学" }]
    arr.fakeFlat(Infinity)
    // [1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 1, 2, 3, 5, "string", { name: "弹铁蛋同学" }];

    第七问:考虑数组空位的情况

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

    所以我们可以利用上面几种方法来实现 flat 跳过空位的特性

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

    扩展阅读:由于空位的处理规则非常不统一,所以建议避免出现空位。

    ES5 对空位的处理,就非常不一致,大多数情况下会忽略空位。

    • forEach()filter()reduce()every() 和some() 都会跳过空位。
    • map() 会跳过空位,但会保留这个值。
    • join() 和 toString() 会将空位视为 undefined,而undefined 和 null 会被处理成空字符串。

    ES6 明确将空位转为 undefined

    • entries()keys()values()find() 和 findIndex() 会将空位处理成 undefined
    • for...of 循环会遍历空位。
    • fill() 会将空位视为正常的数组位置。
    • copyWithin() 会连空位一起拷贝。
    • 扩展运算符(...)也会将空位转为 undefined
    • Array.from 方法会将数组的空位,转为 undefined

     

    展开全文
  • `` 实现数组flat,filter // 数组扁平化 toString().split(',') // 展平一级 function flat(arr){ var result = []; for(var i = 0; i ; i++){ if(Array.isArray(arr[i])){ result = result.concat(flat(arr[i])) }...
  • js实现数组flat

    2021-01-26 17:54:37
    Array.prototype.myFlat = function(d = 1) { let arr = [...this]; return d > 0 ? arr.reduce((acc, val) => { return acc.concat(Array.isArray(val) ? val.myFlat(d - 1) : val) },[]) ...
  • 数组扁平化——flat方法理解

    千次阅读 2020-08-27 16:47:38
    flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 参数: 指定要提取嵌套数组的结构深度,默认值为 1。 简单理解:就是要减去数组的层数(要讲数组降低...
  • es6数组flat()方法

    2021-11-10 09:03:51
    flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 Array.prototype.flat() 用于将嵌套的数组“扁平化”,将二维数组变成一维数组。该方法返回一个新...
  • 多维数组降维 flat()方法的作用和用法 一、作用 flat()方法用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。 二、用法 示例:let arr = [1,2,3,[4,5,[6,7],8],9] arr.flat() ...
  • 数组flat方法【Array.prototype.flat()】

    千次阅读 2019-10-12 10:34:24
    数组flat方法【Array.prototype.flat()】 一、 概念   flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 二、语法结构 var newArray = arr.flat(...
  • es6之数组flat(),flatMap()

    万次阅读 多人点赞 2019-01-17 19:52:28
    数组的成员有时还是数组,Array.prototype.flat()用于将嵌套的数组“拉平”,变成一维数组。该方法返回一个新数组,对原数据没有影响。 [1, 2, [3, 4]].flat() // [1, 2, 3, 4] 上面代码中,原数组的成员里面有一个...
  • js 数组扁平化处理flat

    2020-11-18 21:58:38
    js 数组扁平化处理flat1、直接调用flat2、正则表达式匹配3、递归4、数组累加器reduce5、展开运算符...和while循环 1、直接调用flat flat (arr) { return arr.flat(Infinity) }, 2、正则表达式匹配 flat1 (arr) ...
  • 数组扁平化: 用于将嵌套多层的数组“拉平”,变成一维的数组 1、[1, [2]] => [1,2] 2、[[1, 2], [3, 4]] => [1, 2, 3, 4] 3、[1, 2, [3, 4, [5, 6]]] => [1, 2, 3, 4, 5, 6] 复制代码方法一: 使用ES2019...
  • js数组扁平化的方法(flat)方法的总结: /* * js数组扁平化的方法(flat)方法的总结 */ /* *方法1: */ let arr=[1,[2,34,[4,5]]]; let str=JSON.stringify(arr);// [1,[2,34,[4,5]]] // 方式1:flat() console....
  • Array.from()方法, 数组实例flat()方法.
  • JS数组方法 flat(),flatMap() ヤッハロー、Kaiqisanすうう、一つふつうの学生プログラマである。这一节是我最后的一个数组方法的专题,是之前的遗漏的东西,今天把它彻底讲完,然后皆大欢喜。 flat(val):高维数组...
  • 带你手动实现JS数组扁平化flat()方法

    千次阅读 2020-07-11 00:44:41
    // 重写数组flat方法 // 1.会去掉数组的空项 // 2.返回新数组 Array.prototype.myFlat = function(dep = 1) { return this.reduce((acc, val) => { return acc.concat(val instanceof Array &&am
  • let arr = [1, [2, [3, [4, 5]]], 6] let str = arr.flat(Infinity) console.log(str) // [1, 2, 3, 4, 5, 6] // flat()会去空值,但不会去重
  • https://www.jb51.net/article/184977.htm
  • var arr1 = [1, 2, [3, 4]]...arr1.flat(); // [1, 2, 3, 4] var arr2 = [1, 2, [3, 4, [5, 6]]]; arr2.flat(); // [1, 2, 3, 4, [5, 6]] var arr3 = [1, 2, [3, 4, [5, 6]]]; arr3.flat(2); // [1, 2, 3, 4, 5, ...
  • 数组扁平化:将数组中嵌套的数组拉平变成一维数组。 方法1:reduce,遍历数组每一项,若值为数组则递归遍历,否则concat 代码如下 let arr = [1, [2, 3, [4, 5], 6]]; //方法1:reduce,遍历数组每一项,若值...
  • 一、numpy.flatten" role="presentation" style="position: relative;">一、numpy.flatten一、numpy.flatten一、numpy.flatten ... 将数组变为一维 Parameters: order : {‘C’,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,579
精华内容 8,631
关键字:

数组flat