精华内容
下载资源
问答
  • new Set数组去重

    千次阅读 2021-01-23 20:08:48
    利用该方法去重 <script> let arr = [1,1,3,3,4,4,5] console.log([...new Set(arr)]); //打印数组[1,3,4,5] </script>

    利用该方法去重

        <script>
            let arr = [1,1,3,3,4,4,5]
            console.log([...new Set(arr)]);
            //打印数组[1,3,4,5]
        </script>
    
    展开全文
  • 其实很简单,一般的数组去重可以直接用 new Set() 方法即可,但是数组对象的话,比较复杂,不能直接用,我们可以采取间接的方法来去重 unique(arr) { const res = new Map(); return arr.filter((arr) => !res....
  • new set 数组去重和Array.from用法

    千次阅读 2020-05-15 09:41:25
    new Set(),用来去重数组。 let arr = [1, 2, 2, 3]; let set = new Set(arr); let newArr = Array.from(set); console.log(newArr); // [1, 2, 3]
    new Set(),用来去重数组。
    
    
    
    let arr = [1, 2, 2, 3];
    
    let set = new Set(arr);
    
    let newArr = Array.from(set);//Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组
    
    console.log(newArr); // [1, 2, 3]
    
    ------------------------
    
    Array.from
    
    let arrayLike = {
    
        0: 'tom', 
    
        1: '65',
    
        2: '男',
    
        3: ['jane','john','Mary'],
    
        'length': 4
    
    }
    
    let arr = Array.from(arrayLike)
    
    console.log(arr) // ['tom','65','男',['jane','john','Mary']]
    
    ----
    
     那么,如果将上面代码中length属性去掉呢?实践证明,答案会是一个长度为0的空数组。
    
      这里将代码再改一下,就是具有length属性,但是对象的属性名不再是数字类型的,而是其他字符串型的,代码如下:
    
    let arrayLike = {
    
        'name': 'tom', 
    
        'age': '65',
    
        'sex': '男',
    
        'friends': ['jane','john','Mary'],
    
        length: 4
    
    }
    
    let arr = Array.from(arrayLike)
    
    console.log(arr)  // [ undefined, undefined, undefined, undefined ]
    
    1、该类数组对象必须具有length属性,用于指定数组的长度。如果没有length属性,那么转换后的数组是一个空数组。
    
      2、该类数组对象的属性名必须为数值型或字符串型的数字
    
      ps: 该类数组对象的属性名可以加引号,也可以不加引号
    
    2、将Set结构的数据转换为真正的数组: 
    
    
    
    let arr = [12,45,97,9797,564,134,45642]
    
    let set = new Set(arr)
    
    console.log(Array.from(set))  // [ 12, 45, 97, 9797, 564, 134, 45642 ]
    
      
    
      Array.from还可以接受第二个参数,作用类似于数组的map方法,用来对每个元素进行处理,将处理后的值放入返回的数组。如下:
    
    
    
    let arr = [12,45,97,9797,564,134,45642]
    
    let set = new Set(arr)
    
    console.log(Array.from(set, item => item + 1)) // [ 13, 46, 98, 9798, 565, 135, 45643 ]
    
    3、将字符串转换为数组: 
    
    let  str = 'hello world!';
    
    console.log(Array.from(str)) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d", "!"]
    
     4、Array.from参数是一个真正的数组:
    
    console.log(Array.from([12,45,47,56,213,4654,154]))返回一个一模一样的新数组

     

    展开全文
  • 数组去重,ES6数组去重 new Set()

    千次阅读 2020-07-08 12:30:18
    普通数组去重 varb=[...newSet([1,2,3,4,5,5,5,5])] console.log(b); 输出结果: 包含对象的数组去重 var o ={a:1} var b = [...new Set([o, o, 3, 4, 5, 5, 5, 5])] console.log(b); 输出结果: ...

    普通数组去重

        var b = [...new Set([1,2, 3, 4, 5, 5, 5, 5])]
    
        console.log(b);

    输出结果:

     

    包含对象的数组去重

        var o ={a:1}
        var b = [...new Set([o, o, 3, 4, 5, 5, 5, 5])]
        console.log(b);

    输出结果:

     

    包含对象的数组去重有一个坑

        var b = [...new Set([{'a':1}, {'a':1}, 3, 4, 5, 5, 5, 5])]
        console.log(b);

    因为每个对象都是唯一的,所以这个数组里面的两个对象没办法去重

     

    去除字符串里面的重复字符

    [...new Set('ababbc')].join('')
    // "abc"
    展开全文
  • js最简单的数组去重方法set数组去重 function newArr(arr) { return Array.from(new Set(arr)) }

    js最简单的数组去重方法set数组去重

    数组去重

    function newArr(arr) {
    	return Array.from(new Set(arr))
    }
    

    对象数组去重
    arr是数组参数,type是要根据去重的字段参数

    function newArr(arr,type) {
    	var newArr = [];
    	var tArr = [];
    	if (arr.length == 0) {
    		return arr;
    	} else {
    		if (type) {
    			for (var i = 0; i < arr.length; i++) {
    				if (!tArr[arr[i][type]]) {
    					newArr.push(arr[i]);
    					tArr[arr[i][type]] = true;
    				}
    			}
    			return newArr;
    		} else {
    			for (var i = 0; i < arr.length; i++) {
    				if (!tArr[arr[i]]) {
    					newArr.push(arr[i]);
    					tArr[arr[i]] = true;
    				}
    			}
    			return newArr;
    		}
    }
    }
    
    展开全文
  • 使用New Set()用来数组去重 Set类似于数组,区别在于它所有的成员都是唯一的,不能有重复的值 var arr = [1,1,'true','true',true,true,2,2,'b','b',false,false,'NaN',NaN,{},{}] var set = new Set(arr);//去掉...
  • es6中Set数组去重用法

    2020-11-26 13:41:11
    var arr = [1, 4, 5, 1, 4, 3, 1, 7], arr1 = [2, 7, 9], arr2 = [8, 0]; var str = ‘abcdefgacd’; var obj = { ‘a’: ‘1’, ‘b’:...//数组去重简写 //[1, 2, 3, 4, 5, 7, 8, 9, 0] console.log(Array.from(new
  • this.typeDevice.map(item => { return item.info_name }) //new Set实现数组去重 keys = [...new Set(keys)] let newArr = [] //循环去重后的数组 keys...
  • ES6提供了新的数据结构Set,类似于数组,但成员的值都是唯一的,没有重复的值,因此可以利用Set去重Set本身是一个构造函数,用来生成Set数据结构,使用时可以直接new Set()进行使用。 // Set函数可以接收一个数组...
  • Array from(new Set)去重原理

    千次阅读 2020-10-29 14:08:09
    Array from(new Set)去重原理数组转为数组 1、Array from 2、 Array.prototype.slice.call(arguments); Array.from()在转化对象时,要求过于苛刻,因此不适用于转化对象,主要场景如下: (1)从类数组对象...
  • Set 主要用于数组去重 let set1 = new Set(); set1.add(1); set1.add(2); set1.add(3); set1.add(3); console.log(set1); // Set {1, 2, 3} // convert a set to an array let new_array = Array.from(set1); ...
  • 前端 Set实现数组去重

    2021-11-01 11:02:25
    Set是ES6中新的对象,利用它可以快速数组去重
  • 使用newSet实现数组去重必须结合forof,如果使用for循环就实现不了 var arr = new Set([1, 2, 1, 1, 2, 3, 3, 4, 4]); for (var el of arr) { console.log(el) }   转载于:...
  • Javascript数组去重(利用new Set

    千次阅读 热门讨论 2021-06-15 15:09:58
    Set 是什么?... let set1 = new Set(arr1) 返回的是一个类数组,就是类似于数组但是实际上原型是Object console.log(set1) // Set(4) {1, 2, 3, 4} 可以利用Array.from来将他转成真正的数组 let newArr
  • set方法数组去重

    2021-08-16 23:21:55
    var arr = [1, 2, 1] // set对象的特点内部元素不能重复,一般用于数组去重 var arr2 = [...new Set(arr)] console.log(arr2);
  • 数组去重new Set

    千次阅读 2018-03-23 16:57:00
    数组去重 最简单的方法,不过是ES6的方法 var arr = [5,6,6,7,8]; var set = new Set(arr) // {5,6,7,8} var newArr = Array.from(set) // 再把set转变成array console.log(newArr) // [5,6,7,8] 转载于:...
  • JS技巧---Set数组去重

    万次阅读 2018-08-23 11:09:52
    在 ES6 中,引入了一个新的数据结构类型:Set。而 Set 与 Array 的结构是很类似...下面我们看看用 Set 和 …(拓展运算符)可以很简单的进行数组去重。 const removeDuplicateItems = arr =&gt; [...new Set(ar...
  • JS数组去重的方法及原理(全)

    千次阅读 2020-01-28 20:21:37
    前端遇到最多的无非就是循环,判断,处理后台返回的数据了,那么今天介绍一下数组去重的几种常用方法。 一,
  • js对象数组去重,简单数组去重

    千次阅读 2020-06-24 22:37:11
    JavaScript对象数组去重一、对象数组去重方式一二、对象数组去重方式二三、简单类型的数组去重 一、对象数组去重方式一 使用reduce函数。 let arr = [ { key:'1', name:'林青霞' }, { key:'2', name:'张三丰...
  • es6 set对象 set方法 set应用数组去重

    千次阅读 2019-11-08 13:41:29
    let sets = new Set([1,2]) console.log(sets); 不能直接添加数字 let sets = new Set(2) 方法 set.size 类似于数组长度 let sets = new Set() sets.size;//0 set.prototype.add 添加 let sets = new Set() se....
  • set的创建 let set = new Set(); let set = new Set(array); // 传入一个数组,可以对数组进行去重,区分类型,因为set的元素唯一 方法: add(value); clear(); delete(value); has(value); 属性: 元素唯一性 size
  • set 数组去重

    2021-06-01 11:07:48
    //利用set数组去重 let arr = [1,3,3,4]; let set = new Set(arr); // console.log([...set]); console.log(Array.from(new Set(arr)));
  • Set实现数组去重

    千次阅读 2019-10-04 03:01:18
    ES6 提供了新的数据结构 Set 它类似于数组,但是成员的值都是唯一的,没有重复的值 ...第一种数组去重方法(使用Array.from): let arr = [12,43,23,43,68,12]; let item = new Set(arr); co...
  • 数组去重--new Set()

    千次阅读 2019-04-13 12:00:01
    今天看到了个去重的方法: new Set()。 Set是一种类似于数组的结构,本身成员都是唯一的,具体内容介绍,可以查看阮一峰大牛的es6教程,放下链接: http://es6.ruanyifeng.com/#docs/set-map。 很简单的一个...
  • var arr = [5,6,6,7,8]; var set = new Set(arr) // {5,6,7,8} var newArr = Array.from(set) // 再把set转变成array console.log(newArr) // [5,6,7,8]
  • 有以下对象数组: const list =[ { name: "张三", age: 18, address: "北京" }, { name: "李四", age: 20, address: "天津" }, { name: "王五", age: 22, address: "河北" }, { name: "张三", age: 18, address:...
  • 数组去重的几种方法一、for循环判断二、ES6中的Set对象1、一个数组去重2、两个数组合并去重(取合集)三、对象数组去重 一、for循环判断 let a=[1,2,4,2,3,1,2,2] function duplRem(arr) { let b=[]; let flag=...
  • 利用数据类型Set 实现数组去重 Set 作用和数组类似,和数组不同的是:他不能存放重复的元素 基本使用 let set1 = new Set([10, 20, 30, 40, 10, 20, 30, 50]); console.log(set1); //Set { 10, 20, 30, 40, 50 } ...
  • 思路:定义一个新数组,并存放原数组的第一个元素,然后将元素组一一和新数组的元素对比,若不同则存放在新数组中。 function unique(arr) { let newArr = [arr[0]]; for (let i = 1; i < arr.length; i++) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,994
精华内容 12,397
关键字:

newset数组去重原理