精华内容
下载资源
问答
  • JavaScript中数组去重的几种方法正常情况下,数据去重的工作一般都是由后端同事来完成的,但是前端也要掌握好处理数据的能力,万一去重的工作交给我们大前端处理,我们也不能怂呀。现在我总结了一些去重的方法,希望...

    JavaScript中数组去重的几种方法

    正常情况下,数据去重的工作一般都是由后端同事来完成的,但是前端也要掌握好处理数据的能力,万一去重的工作交给我们大前端处理,我们也不能怂呀。现在我总结了一些去重的方法,希望对大家有点帮助。

    方法一:new Set()实现数组去重

    ES6 提供了新的数据结构 Set,它类似于数组,但是成员的值都是唯一的,没有重复的值。 Set 本身是一个构造函数,用来生成 Set 数据结构。Set函数可以接受一个数组,用于初始化。根据 Set的数据特性,我们可以实现数组去重。

    let list = [1, 1, 'a', 'a', true, true, false, false, null, '', null, '', undefined, undefined];

    let list1 = Array.from(new Set(list)); // [ 1, "a", true, false, null, "", undefined ]

    let list2 = [...new Set(list)]; // [ 1, "a", true, false, null, "", undefined ]

    方法二:some()+循环去重

    some() 方法用于检测数组中的元素是否满足指定条件(函数提供) 。 如果有一个元素满足条件,则表达式返回true , 剩余的元素不会再执行检测。 如果没有满足条件的元素,则返回false。 我们可以定义一个新数组来承接没有重复的数据,遍历原始数组的时候,用新数组来判断数据是否已经出现过。

    function distinct(list) {

    let result = [list[0]];// 用于承接没有重复的数据,初始时将原始数组的第一个值赋给它。

    for (let i = 1; i < list.length; i++) {

    // 判断结果数组中是否存在一样的值,若果没有的话则将数据存入结果数组中。

    if (!(result.some(val => list[i] === val))) {

    result.push(list[i]);

    }

    }

    return result;

    }

    let arr = [1, 1, 'a', 'a', true, true, false, false, null, '', null, '', undefined, undefined];

    distinct(arr); // [ 1, "a", true, false, null, "", undefined ]

    方法三:双重for循环去重

    双重for循环,第一层循环确保数组中的每一项都能被比较,第二层循环确保被比较项后的每一项都能跟被比较项比较。

    function distinct2(list) {

    for (let i = 0; i < list.length; i++) {

    for (let j = i + 1; j < list.length; j++) {

    // 后面数据的若跟前一项数据相同,则重复,需要去除。

    if (list[i] === list[j]) {

    list.splice(j, 1); // 去除后面的相同项

    j--;

    }

    }

    }

    return list;

    }

    let arr = [1, 1, 'a', 'a', true, true, false, false, null, '', null, '', undefined, undefined];

    distinct2(arr); // [ 1, "a", true, false, null, "", undefined ]

    方法四:hasOwnProperty()方法去重

    hasOwnProperty() 方法用来检测一个属性是否是对象的自有属性,而不是从原型链继承的。如果该属性是自有属性,那么返回 true,否则返回 false。

    function unique(arr) {

    var obj = {}; // 用来记录数组中的数据

    return arr.filter(function(item, index, arr){

    // 如果记录对象中存在某个数据,则返回false过滤掉;否则obj进行记录并筛选出来

    return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)

    })

    }

    let arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

    unique(arr) // [ 1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, 'a', {}]

    方法五:利用filter()+indexOf()方法去重

    indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。

    function unique(arr) {

    return arr.filter(function(item, index, arr) {

    // 从数组0位开始查,如果当前元素在原始数组中的第一个索引==当前索引值,说明它是第一次出现。

    return arr.indexOf(item, 0) === index;

    });

    }

    let list = [1, 1, 'a', 'a', true, true, false, false, null, '', null, '', undefined, undefined];

    unique(list); // [ 1, "a", true, false, null, "", undefined ]

    此外,数组去重还可以利用filter()、includes()等方法实现,但是思路都跟上面几种方法类似,这里就不一一列举了。

    展开全文
  • 去重在我们的开发过程经常遇到,避免重复元素的添加,我们需要对获取到的集合(包括List、Array等)做相关的过滤操作。确保对象一.前言去重在我们的开发过程经常遇到,避免重复元素的添加,我们需要对获取到的集合...

    去重在我们的开发过程中经常遇到,避免重复元素的添加,我们需要对获取到的集合(包括List、Array等)做相关的过滤操作。确保对象

    一.前言

    去重在我们的开发过程中经常遇到,避免重复元素的添加,我们需要对获取到的集合(包括List、Array等)做相关的过滤操作。确保对象的唯一性,从而达到保证数据不冗余重复。由于自己是做.net方面的开发,所以就拿C#语言中常用的去重方式来学习。如果有其他更好的方式,希望各位大牛指出来,自己也学习学习,在此十分感谢!

    二.C#一般性去重

    static void Main(string[] args)

    {

    //1.集合的定义

    List listArr = new List { 1, 2, 3, 5, 8, 10 };

    List listArrCompare = new List { 2, 3, 4, 8, };

    var num1 = "";

    var num2 = "";

    var num3 = "";

    //2.集合的操作

    listArr.AddRange(listArrCompare);  //将listArr和listArrCompare合并

    List resultList = listArr.Union(listArrCompare).ToList();          //剔除重复项

    List ResultSameList = listArr.Concat(listArrCompare).ToList();        //保留重复项

    foreach (var item1 in listArr)

    {

    num1 = num1 + "," + item1.ToString();

    }

    foreach (var item2 in resultList)

    {

    num2 = num2 + "," + item2.ToString();

    }

    foreach (var item3 in ResultSameList)

    {

    num3 = num3 + "," + item3.ToString();

    }

    Console.WriteLine(num1);

    Console.WriteLine(num2);

    Console.WriteLine(num3);

    Console.ReadKey();

    }

    结果:

    539d948dbaf1f42739d6625a91d5ca39.png

    c#中还有很多去重的方案,在这里说到了最基础的,对于Dictionary、HashTable、HashSet等都可以利用到去重的方法。

    HashSet的Add方法返回bool值,在添加数据时,如果发现集合中已经存在,则忽略这次操作,并返回false值。

    而Hashtable和Dictionary碰到重复添加的情况会直接抛出错误。

    三.c#采用for循环遍历对比去重

    //一个集合内部的集合去重,采用循环比较

    var temp = "";

    List lstall = new List { 1, 2, 3, 4, 5, 5, 8, 8, 10 };

    for (int i = 0; i < lstall.Count - 1; i++)

    {

    for (int j = lstall.Count - 1; j > i; j--)

    {

    if (lstall[i] == lstall[j])

    {

    lstall.RemoveAt(j);

    }

    }

    }

    foreach (var item in lstall)

    {

    temp += item.ToString() + ",";

    }

    Console.WriteLine(temp);

    Console.ReadKey();

    结果:

    a798f747ca684c57a5076675735c4178.png

    四.Distinct去重

    //利用distinct去重

    List strSameList = new List();

    strSameList.Add("武汉");

    strSameList.Add("武汉");

    strSameList.Add("上海");

    strSameList.Add("上海");

    strSameList.Add("南京");

    strSameList.Add("南京");

    strSameList.Add("帝都");

    strSameList.Add("石家庄");

    String myList = String.Empty;

    IEnumerable distinctList = strSameList.Distinct();

    foreach (String str in distinctList)

    {

    myList += str + " ,";

    }

    Console.WriteLine(myList);

    Console.ReadKey();

    结果:

    603d09b8cdf67c85be85a8bd81934123.png

    五.Javascript中去重

    Javascript中我们经常遇到数组去重的情况,那我们一般采取什么样的方式了?

    通过学习以及网上一些资料,自己将一些方法总结如下:

    5.1第一种方法:

    通过定义Array对象原型的方法,那么数组都可以调用该方法对本身重复的元素Drop。

    因Array原型上的方法对于不同的Array对象时共享的。

    展开全文
  • JavaScript中数组去重

    2021-06-09 10:47:02
    //ES6方法 var arr2 = [1, 2, 3, 1, 6, 2, 3] let set = new Set(arr2); console.log([...set]); // console.log([...new Set(arr2)]) //简写 console.log(Array.from(new Set(arr2)... //提前定义一个空数组ne...
     //ES6方法
            	var arr2 = [1, 2, 3, 1, 6, 2, 3]
                let set = new Set(arr2);
                console.log([...set]);
                // console.log([...new Set(arr2)])  //简写
                console.log(Array.from(new Set(arr2)))
    
                //提前定义一个空数组newArr1,遍历数组的长度,(indexOf():判断元素第一次出现的位置,如果没有出现,返回-1;)如果newArr1中没有该元素,则返回-1,进入if判断,将该元素push到newArr1数组中。如果newArr1已经有了该元素,indexOf()将返回该元素的索引,将不会进入if判断,以此循环,直到循环结束
                var newArr1 = [];
                for(var i = 0;i<arr2.length;i++){
                    if(newArr1.indexOf(arr2[i])==-1){
                        newArr1.push(arr2[i])
                    }
                }
                console.log(newArr1);
    
                //定义一个空数组newArr2和空对象obj,遍历数组的长度,首先先看arr2[i]的值,i从0开始,所以第一遍的arr2[i]=0,再看obj[0]将会为false,然后将其取反,进入循环。将arr2[i]索引值赋值给相对应的obj[arr2[i]],然后将其push到newArr2数组中,如果遇到重复的,将不会进入循环
                var newArr2 = []
                var obj = {}
                for(var i=0; i<arr2.length; i++){
                    if(!obj[arr2[i]]){
                        obj[arr2[i]] = arr2[i]
                        newArr2.push(arr2[i])
                    }
                }
                console.log(newArr2);
                 // 定义一个newArr3,将arr2添加一个filter的方法,item:代表该数组的每个元素;index:表示每个元素的索引值;self:该数组。后面需要return 一个满足的条件;我们的条件是,该数组的元素的第一次出现的位置的索引值是否等于他原本index的索引值,如果等于,即将其返回给newArr3,如果不等于,就表示该元素是重复值,直接跳过
                let newArr3 = arr2.filter((item,index,self)=>{
                    // return 满足的条件
                    return self.indexOf(item) = index;
                })
                console.log(newArr3);

     

    展开全文
  • 2019.08.02补:对象数组建议直接循环然后使用工具库(lodash)的深比较,评论里也有指出,文章的方法有些取巧了 生产环境不要这么玩~。方法一:利用ES6的Array.from()/扩展运算符 以及 SetArray.from(): The Array....

    2019.08.02补:

    对象数组建议直接循环然后使用工具库(lodash)的深比较,评论里也有指出,文章的方法有些取巧了 生产环境不要这么玩~。

    方法一:利用ES6的Array.from()/扩展运算符 以及 Set

    Array.from(): The Array.from() method creates a new Array instance from an array-like or iterable object.

    该方法接收两个参数要转换的非数组对象,对每个元素进行处理的方法(可选).在js中,有很多类数组对象(array-like object)和可遍历(iterable)对象(包括ES6新增的数据结构Set和Map),常见的类数组对象包括document.querySelectorAll()取到的NodeList,以及函数内部的arguments对象。它们都可以通过Array.from()转换为真正的数组,从而使用数组的方法。事实上只要对象具有length属性,就可以通过Array.from()转换为真正的数组。

    Set:A collection of unique values that may be of any type.

    Set:一个可以是任何类型的独一无二的值的集合.

    function unique(arr){

    return Array.from(new Set(arr));

    }

    你也可以这样写:

    function unique(arr){

    return [...new Set(arr)];

    }

    方法二:遍历数组,建立新数组,利用indexOf判断是否存在于新数组中,不存在则push到新数组,最后返回新数组

    Determines the index of the specific IThing in the list.

    indexOf() :方法可返回某个指定的字符串值在字符串中首次出现的位置。如果没有则返回-1

    function unique(arr){

    var newArr = [];

    for(var i in arr) {

    if(newArr.indexOf(arr[i]) == -1) {

    newArr.push(arr[i])

    }

    }

    return newArr;

    }

    方法三:遍历数组,利用object对象的key值保存数组值(key不重复),判断数组值是否已经保存在object中,未保存则push到新数组并用object[arrayItem]=true的方式记录保存.

    function unique(arr) {

    let hashTable = {};

    let newArr = [];

    for(let i=0,l=arr.length;i

    if(!hashTable[arr[i]]) {

    hashTable[arr[i]] = true;

    newArr.push(arr[i]);

    }

    }

    return newArr;

    }

    方法四:先排序,新数组最后一项为旧数组第一项,每次插入判断新数组最后一项是否与插入项相等

    function unique(arr) {

    var newArr = [];

    var end; //end其实就是一道卡

    arr.sort();

    end = arr[0];

    newArr.push(arr[0]);

    for (var i = 1; i < arr.length; i++) {

    if (arr[i] != end) {

    newArr.push(arr[i]);

    end = arr[i]; //更新end

    }

    }

    return newArr;

    }

    以上四种方法都是对于基本数据类型而言,如果换做对象数组就无能为力了,下面是对象数组的去重方法

    方法一:利用对象的键名不能重复的特点

    function unique(arr){

    let unique = {};

    arr.forEach(function(item){

    unique[JSON.stringify(item)]=item;//键名不会重复

    })

    arr = Object.keys(unique).map(function(u){

    //Object.keys()返回对象的所有键值组成的数组,map方法是一个遍历方法,返回遍历结果组成的数组.将unique对象的键名还原成对象数组

    return JSON.parse(u);

    })

    return arr;

    }

    map方法使用示例:

    var map = Array.prototype.map

    var a = map.call("Hello World", function(x) { return x.charCodeAt(0); })

    // a的值为[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]

    存在的问题:

    {x:1,y:2}与{y:2,x:1}通过JSON.stringify字符串化值不同,但显然他们是重复的对象.

    方法二:还是利用对象的键名无法重复的特点,必须知道至少一个对象数组中的对象的属性名

    var songs = [

    {name:"羽根",artist:"air"},

    {name:"羽根",artist:"air"},

    {name:"晴天",artist:"周杰伦"},

    {name:"晴天",artist:"周杰伦"},

    {artist:"周杰伦",name:"晴天"}

    ];

    function unique(songs){

    let result = {};

    let finalResult=[];

    for(let i=0;i

    result[songs[i].name]=songs[i];

    //因为songs[i].name不能重复,达到去重效果,且这里必须知晓"name"或是其他键名

    }

    //console.log(result);{"羽根":{name:"羽根",artist:"air"},"晴天":{name:"晴天",artist:"周杰伦"}}

    //现在result内部都是不重复的对象了,只需要将其键值取出来转为数组即可

    for(item in result){

    finalResult.push(result[item]);

    }

    //console.log(finalResult);[{name:"羽根",artist:"air"},{name:"晴天",artist:"周杰伦"}]

    return finalResult;

    }

    console.log(unique(songs));

    原数组(重复).png

    result.png

    finalResult.png

    展开全文
  • 数组去重的5种方法:1、用“[...new Set(arr)]”语句去重;2、用“Array.from(new Set(arr))”语句去重;3、利用indexOf()去重;4、利用includes()去重;5、利用filter()去重。 本教程操作环境:windows7系统、...
  • js map 数组去重

    2021-10-26 10:02:03
    方法一 let list = [{ "key": 108, "label": "陈思齐-13956724034-企业人和", "state": 1 }, { "key": 10354, "label": "黄科军-15000087703-企业人和", "state": 2 ... "label": "李嘉泰-1500
  • js中数组去重

    2021-03-12 15:22:32
    let arr = [1, 2, 3, 4, 4, 1] let newArr = arr.reduce((pre, cur) => { console.log(pre,cur) if (!pre.includes(cur)) { return pre.concat(cur) } else { return pre } }, []) ...结果:
  • js实现数组去重的7种方式
  • JS中对象数组去重

    2021-04-22 11:32:38
    * @param {数组} arr * @param {根据哪个属性去重} key */ newArr(arr,key) { var result = []; let obj = {}; arr.forEach(v => { if (!obj[v[key]]) { result.push(v) obj[v[key]] = true } }) ...
  • 31小时5分钟前回答python redis连接 有序集合去重的实例内容python redis连接 有序集合去重的代码如下所述: # -*- coding: utf-8 -*- import redisfrom constant import redis_ip, redis_db, redis_pw, redis_zset_...
  • 对于对象数组去重,如果用for循环等来写,很不美观。下面reduce实现起来很nice // 对象数组去重, arr 数组, key 关键字 arrRemoveRepeat(arr, key) { var obj = {}; // 利用reduce方法遍历数组,reduce第一个...
  • JS中数组去重的几种方法 利用push数组的实现方法 one: 定义一个新数组,遍历原数组,然后按顺序放入原数组的元素,放入前对比两个数组元素是否有重复,不同则放入。 注意:用到的数组方法有: .push(date)在...
  • 一、创建新数组,把原数组中不重复的值存到新数组中 1. 利用indexOf()方法:可返回某个指定的字符串值在字符串首次出现的位置。 下面看一个简单例子,熟悉一下indexOf() 方法的用法。 let str = 'orange'; str...
  • js对象数组去重

    2021-03-23 11:16:08
    // 对象数组去重 arrDuplicateRemoval(arr, id) { const res = new Map(); return arr.filter((arr) => !res.has(arr[id]) && res.set(arr[id], 1)); }
  • 2021-js对象数组去重

    2021-04-23 08:08:43
    js对象数组去重 let areaTypelist: API.OptionsData[] = [{ label: 'L290', value: '张三' },{ label: 'L290', value: '张三' }]; let obj: API.OptionsData = {}; //根据label去重 areaTypelist = ...
  • 方法一:双层循环,外层循环元素,内层循环时比较值如果有相同的值则跳过,不相同则push进数组Array.prototype.distinct = function(){var arr = this,result = [],i,j,len = arr.length;for(i = 0; i < len; i++...
  • 招银网络科技</li> <li>https://cmbnt.cmbchina.com/</li> <ul> </body> <script> var arr = [1,2,2,22,4,5,5,5] //数组去重最简单方法 var newArray = new Set(arr) console.log('---',[...newArray]);...
  • 数组对象去重完毕了,也看看数组去重吧。 一、第一种方法 使用indexOf()和push()进行数组去重。 indexOf() 方法可返回某个指定的字符串值在字符串首次出现的位置。 如果没有找到匹配的字符串则返回 -1。 注意...
  • 数组去重的六种方法请查收~~~~~~。 方法1:简单方便之Set() let arr = [1, 2, 3, 2, 1, 3, 4, 2, 5]; //方法1:set去重 let res1 = new Set(arr); console.log([...res1]); 记得输出时用展开语法将结果放到数组...
  • JS 数组去重 9种办法 利用key 的唯一性 交换元素位置从而替换掉 splice 方法 Array.fliter + Array.indexOf Array.fliter + Object.hasOwnProperty Array.reduce + Array.includes Array.indexOf Array.includes ...
  • 今天来聊一聊js数组去重的一些方法,包括一些网上看到的和自己总结的,总共5种方法,希望对大家有帮助。第一种:遍历数组法这种方法最简单最直观,也最容易理解,代码如下:这种方法很好理解,利用了indexOf()方法...
  • 1. 简单数组去重 1.1 new Set() 去重 MDN对于Set的释义:Set对象是值的集合,你可以按照插入的顺序迭代它的元素。 Set的元素只会出现一次,即 Set 的元素是唯一的。 执行Set后返回的是一个Set结构,是类数组 ...
  • js一维数组去重

    2021-03-13 16:59:39
    就拿查询MySQL获取结果集并在页面上显示数据为例来分析. HTTP请求由C级别的程序比如Apache/Nginx处理(Java的HTTP服务用的是Java开发的Tomcat等), PHP则...这点是Java等其他语言(包括RoR/Python/Node.JS)所不能媲美的.
  • 先利用Set创建类数组数据结构实例set,再利用set会自动去重的特性,最后用扩展运算符将set赋值给新数组 var arr = ['a', 'b', 'c', 'a'] var set = new Set(arr) var newArr = [...set] console.log(newArr); ...
  • js中数组去重方法

    2021-06-01 10:39:20
    分别采用set和find方式实现 let strArr = ["1","2","1","3","4"]; let objArr = [{"id":"1"},{"id":"2"},{"id":"1"},{"id":"3"},{"id":"4"}]; let initStrArr = []; let initObjArr = [];...initStrArr = new Set...
  • js数组去重的9种方法

    2021-09-06 15:45:47
    一、利用ES6的 Set 方法去重 注:Set为ES6新增的一个对象,允许存储任何类型(原始值或引用值)的唯一值 let arr = [1,0,0,2,9,8,3,1]; function unique(arr) { return Array.from(new Set(arr)) } console.log...
  • 1. 数组去重 利用indexOf 和 push进行 // 数组的去重 var arr4 = [100, 100, 300, 300, 401, 501, 601]; function unique(arr) { var newArr = []; for (var i = 0; i < arr.length; i++) { // 核心思路
  • 回调可用于数组、计时器函数、promise、事件处理。本文将会解释回调函数的概念,同时帮你区分两种回调:同步和异步。回调函2021-01-15 20:38:08Javascript 实现复制(Copy)动作大全一、实现点击按钮,复制文本框...
  • 数组去重vue js

    2021-07-14 18:38:20
    数组内置对象去重 let objs = {}; this.arrIpt = this.arrIpt.reduce((cur, next) => { objs[next.id] ? "" : (objs[next.id] = true && cur.push(next)); return cur; }, []); 合并去重 let arrs = [] arrs.push...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,095
精华内容 13,238
关键字:

js中数组去重