精华内容
下载资源
问答
  • js二维数组去重

    2021-03-10 10:29:43
    var arr = [{ key: '1', value: '乐乐' }, { key: '2', value: '博博' }, { key: '3', value: '淘淘' },{ key: '4', value: '哈哈' ... // 方法1:利用对象访问属性的方法,判断对象中是否存在ke...

    var arr = [{
          key: '1',
          value: '乐乐'
       }, {
          key: '2',
          value: '博博'
       }, {
          key: '3',
          value: '淘淘'
       },{
          key: '4',
          value: '哈哈'
       },{
          key: '1',
          value: '乐乐'
       }];


       //  方法1:利用对象访问属性的方法,判断对象中是否存在key
       var result = [];
       var obj = {};
       for(var i =0; i<arr.length; i++){
          if(!obj[arr[i].key]){
             result.push(arr[i]);
             obj[arr[i].key] = true;
          }
       }
       console.log(result);

    结果:     [{key: "1", value: "乐乐"},{key: "2", value: "博博"},{key: "3", value: "淘淘"},{key: "4", value: "哈哈"}]
     

    展开全文
  • 本文给大家收藏整理了js数组去重的n种方法,大家可以根据自己需要选择比较好的方法,感兴趣的朋友一起看看吧
  • js 二维数组去重

    2020-04-05 18:50:05
    一维数组肯定用ES6语法 Set来进行去重,当我用到二维数组上的时候,居然不灵。 于是我就谷歌了一下,发现了一个用哈希思想的去重方法,分享给大家。 function Deduplicate() { let tmp = [ [1, 1, 2], [1, 1, 2]...

    一维数组肯定用ES6语法 Set来进行去重,当我用到二维数组上的时候,居然不灵。
    于是我就谷歌了一下,发现了一个用哈希思想的去重方法,分享给大家。

    	function Deduplicate() {
            let tmp = [
                [1, 1, 2],
                [1, 1, 2],
                [3, 4, 5]
            ];
            let hash = {};
            let res = [];
            for (let i = 0; i < tmp.length; i++) {
                if (!hash[tmp[i]]) {
                    res.push(tmp[i]);
                    hash[tmp[i]] = true;
                }
            }
            return res;
        }
        console.log(Deduplicate());
        
        	
    

    在这里插入图片描述

    展开全文
  • JS二维数组去重

    千次阅读 2018-05-16 18:45:22
    在网上找了很多的JS二维数组去重的方法,基本上都有Bug,不是去除不完全就是只能根据特定的条件去除,或者去除了非重复元素。项目中需要解决这个问题,所以自己写了一个方法,方便自己也方便他人,本人已测试过很多...

           在网上找了很多的JS二维数组去重的方法,基本上都有Bug,不是去除不完全就是只能根据特定的条件去除,或者去除了非重复元素。项目中需要解决这个问题,所以自己写了一个方法,方便自己也方便他人,本人已测试过很多数据,修复了很多Bug,如果网友发现了Bug,恳请提出,本人再改进。代码如下:

     

     
    var arr = [
    [1, 2, 'haha'],
    [1, 3, 'haha'],
    [2, 2, 'haha'],
    [1, 2, 'xixi'],
    [1, 2, 'haha'],
    [1, 3, 'haha'],
    [1, 3, 'haha'],
    [1, 3, 'haha'],
    [1, 3],
    [1, 2],
    [1, 3],
    ['he','xi','ze'],
    ['he','xi','ze'],
    ['he','xi','zi'],
    ['he','xi'],
    ['he','xi'],
    ['he','xi','ze','zi']
    ]; // 用于测试的复杂数组
    var temp;
    var count;
    for (var i = 0; i < arr.length; i++) { // 第一次遍历数组,确保数组里的子数组都能被检测
    temp = arr[i]; // 存储被检测的当前子数组
    for (var k = 0; k < arr.length; k++) {
    if (k != i && arr[k].length == temp.length) { // 第二次遍历数组,检测除了被检测数组本身以及两者长度不一样的子数组
    count = 0; // 初始化
    for (var j = 0; j < arr[k].length; j++) { // 遍历检测的子数组
    if (arr[k][j] == temp[j]) {
    count++; // 记录检测子数组与被检测子数组中的元素重复次数
    }
    }
    if (count == temp.length) { // 如果次数与被检测子数组的长度相等,代表两者重复
    arr.splice(k,1); // 删除该重复元素
    k--; // 数组长度变化,K需要减一回到当前位置
    }
    }
    }
    }
    console.log(arr); // 查看效果

     

     

     

           用到了for循环嵌套,从性能上来说有一点不美好,但是如果要到达效果,只能这么做了。如果有朋友能有改进的方法,也欢迎提出。

    展开全文
  • Javascript 二维数组去重

    千次阅读 2016-11-06 20:07:19
    [[a,1],[b,2],[a,2]] 去除[a,2]输入一串url 和一个待去除参数,输出筛选后的结果,第二个参数...// returns 'www.codewars.com?a=1'思路是先将querry参数变成二维数组去重,对象的键值是唯一的,将参数转化为数组后,
    [[a,1],[b,2],[a,2]] 去除[a,2]

    输入一串url 和一个待去除参数,输出筛选后的结果,第二个参数缺省的话,去除重复部分。

    stripUrlParams('www.codewars.com?a=1&b=2&a=2', ['b']) 
    // returns 'www.codewars.com?a=1'

    思路是先将querry参数变成二维数组再去重,对象的键值是唯一的,将参数转化为数组后,遍历数组,若在对象中已经存在参数名称则跳过;否则添加参数与值;然后遍历对象组合URL。代码如下:

    function stripUrlParams(url, arr) {
        var domain = url.substr(0, url.lastIndexOf('?')+1);
        if(url.lastIndexOf('?') == -1) 
            domian = url;
        var query = url.substr(url.lastIndexOf('?')+1);
        var obj = {};
        var argsArr = query.split('&');
        for(var i in argsArr) {
            var tmp = argsArr[i].split('=');
            if(obj[tmp[0]] == null)
                obj[tmp[0]]=tmp[1];
        }
        query = "";
        for(var i in obj) {
            // 去掉arr中的参数
            var is = true;
            if(arr != null)
                for(var j in arr) {
                    if(i == j) 
                        is = false;
                }
            if(is) {
                query += i + "=" + obj[i]+"&";
            }
        }
        return domain + query.substr(0, query.length-1);
    }
    
    var url = stripUrlParams('www.codewars.com?a=1&b=2&a=2', ['b'])
    console.log(url);

    仅仅对于去重问题,可以简单的用一个reduce解决:

    var arr = [['a', 1], ['b', 2], ['a', 2]];
    
    var result = arr.reduce((function () {
      var map = {};
      return function (result, next) {
        var key = next[0];
        if (!map[key]) {
          map[key] = true;
          result.push(next);
        }
        return result;
      };
    })(), []);
    
    console.log(JSON.stringify(result));

    第二种方法:

    function stripUrlParams(url, varible) {
        var urlArr = url.split('?')[1].split('&').map(function(item) {
            return item.split('=');
        })
        var hash = {};
        var result = [];
        for (var i = 0; i < urlArr.length; i++) {
            hash[urlArr[i][0]] ? '' : (hash[urlArr[i][0]] = true, urlArr[i][0] !== varible && result.push(urlArr[i]));
    
        }
        return url.split('?')[0] + '?' + result.reduce(function(prev, next) {
            return prev + next.join('=');
        }, '')
    }
    console.log(stripUrlParams('www.codewars.com?a=1&b=2&a=2&d=8', 'b'));
    //www.codewars.com?a=1d=8

    第三种:
    思路:
    将二维数组转换成一位数组去比较,将二级元素转换为字符串比较方便,但是为了区分类型,引入typeof拼接,之后对这个一维数组查重

    function fun(input) {
        var input = input || [];
        var temp = input.map(function (item) {
            return item.map(function (_item) {
                return _item + ' ' + typeof _item;
            }).join('|');
        });
    
        // temp : ['a string|1 number', 'b string|2 number', 'a string|2 number']
    
        var indexArr = [];
        temp.map(function (item, index, arr) {
            for (var i = 0; i < index; i++) {
                if (arr[i] !== item) indexArr.push(index);
            }
        });
    
        var result = [];
        for (var i = 0; i < indexArr.length; i++) {
            result.push(input[i]);
        }
    
        return result;
    }
    
    console.log(fun(input));

    单层循环来搞定。这个特殊问题,可以转化到单层数组去重问题上。

    var tidy = function(arr) {
        var i = 0,
            j = arr.length,
            cache = {},
            key, result = [];
        for (; i < j; i++) {
            key = arr[i][0];
            key = typeof(key) + key;
            if (!cache[key]) {
                cache[key] = 1;
                result.push(arr[i]);
            }
        }
        return result;
    };

    测试

    var arr = [['a', 1], ['b', 2], ['a', 2]];
    tidy(arr);
    var url = 'www.codewars.com?a=1&b=2&a=2';
    
        var usArr = url.split('?')[1];
        var usMap = {};
        usArr.split('&').forEach(function(a,b){
            var s = a.split('=');
            !usMap[s[0]] && (usMap[s[0]] = s[1]);
        })
        console.log(usMap)
    展开全文
  • js实现二维数组去重

    千次阅读 2019-09-05 15:28:07
    数组中包含数组,怎么去重? 比如数组:[[{a:1},{a:1,b:2}],[{a:1}],[{a:1},{a:1,b:2}]] let arr = [[{a:1},{a:1,b:2}],[{a:1}],[{a:1},{a:1,b:2}]] function getUnique(array){ let obj = {} return array....
  • php的二维数组去重,数据结构重建和js数组去重最简方法
  • 一维数组二维数组去重 一维数组 Array.from(new Set([1,2,3,4,5,2,1])) 二维数组去重 let count=[ { channel_name: "顺友物流渠道2", id: "486", warehouse_list: "8,9", }, { channel_name: "tt
  • js实现一维、二维数组去重 定义两个任意数组: var a=["1","2","4","1","o","dd","bbs1","ooi","a","6","a","s","2","89","89"]; var b=["1","5","7","5","o","ff","bbs","ww","a","6","a","s","2","3","89","ff"]; ...
  • 二维数组去重,说白了就是删除重复项,代码如下: var matrix=[ [1,2,3,4], [3,4,5,6], [1,2,3,4] ] var removeRepeat=function(arr){ var obj={}; for(var i=0;i<arr.len...
  • 非常简单的二维数组去重

    千次阅读 2018-05-18 16:16:33
    前几天有朋友问我数组去重怎么做,我说简单的数组去重很简单啊,他说是对象形式的,我想了想,也有了点思路。 但是我还是上网查了一下,各路大神四面八方杀来,我觉得很麻烦,而且有的方法还不适用我的数组需求,...
  • 今天小编就为大家分享一篇关于js数组去重的方法总结,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 二维数组去重javascript

    2021-07-26 22:10:07
    外层循环:指针 i 遍历数组。 内层循环:用双指针,去寻找满足三数之和 == 0 的元素 先排序的意义: 便于跳过重复元素,如果当前元素和前一个元素相同,跳过。 双指针的移动时,避免出现重复解 找到一个解后,左右...
  • PHP和js二维数组去重

    2019-10-16 18:39:28
    //数组去重 var removeRepeat=function(arr){ var obj={}; for(var i=0;i<arr.length;i++){ // 判断当前项是否遍历过,是则删除,否存入obj以作对照 if(obj.hasOwnProperty(arr[i]))...
  • js二维数组去重记录

    2019-11-11 18:11:58
    let res={}; arr.forEach(item=>{ item.sort((a,b)=>a-b); res[item]=item; }); console.log(Object.values(res)); return Object.values(res)
  • 有时候,我们可能需要数组去重,如果是一维数组,那么直接 ES6 语法 [...new Set(array)] 即可,如果是二维对象数组则无效了(一维数组去重请访问 这篇文章)。 例如以下对象数组,可以看到有两个重复的对象,那么...
  • 二维数组去重

    2020-10-21 18:54:41
    function getUnique(array){ let obj = {} return array.filter((item, index) => { // 防止key重复 let newItem = item + JSON.stringify(item) return obj.hasOwnProperty(newItem) ?...
  • php 5.2.9 版本增加了array_unique对多维数组的支持,在处理多维数组是需要设置sort_flags参数一维数组的重复项:使用array_unique函数即可,使用实例如下: 代码如下复制代码&lt;?php$aa = array("apple&...
  • 其实网上已经有很多js数组去重方法,但是我看了很多篇并自己通过代码验证,发现都有一些缺陷,于是在研究多篇代码之后,自己总结了9种方法,如果有哪里不对请及时纠正我哈~测试代码let arr1 = [3, 1, [1], 1, [1],...
  • new一个Set对象,set方法去重, flat方法扁平化,Infinity规定数组长度的限制 sort方法正序排列, 最后把对象转化成数组: var arry =[1,25,15,[1,2,15,5],15,25,35,1]; var set =new Set(arry.flat(Infinity).sort...
  • 在日常的开发中一般都是处理json数据,最多来个二维数组循环啥的就解决了, 当时心里那个毛毛的,写循环吧,这得循环多少次呀,自己看着都吐的感觉; 心里就一直想着能怎么取到里面的每个元素,然后排序就OK啦,...
  • 二维数组 排序: let arr = [[20,20],[1,1,],[53,53],[72,72],[36,36]] arr.sort((v1, v2) => { return (v1[0] - v2[0]) }) console.log(arr) //[[1, 1],[20, 20],[36, 36],[53, 53],[72, 72]] 去重: let arr =...
  • 数组的方法concat(元素)slice(start,end)splice() 重点join()reverse()sort()indexof() 重点forEach() 重点filter()every() 重点some()map() 1.作用域 变量存在的范围。 任何程序执行都需要占用内存。函数...
  • 1.使用ES6语法 set方法数组去重:: a=[1,2,3,4,1,2,3,4];...2.一维数组去重方法 function unique1(array){ var n = []; //一个新的临时数组 for(var i = 0; i < array.length; i++){ ...
  • JavaScript 数组去重

    2018-09-08 14:40:52
    JavaScript 数组去重 方法:利用对象的属性不能相同的特点进行去重,把数组的属性值添加为对象的属性名(一个对象不能有两个同名的属性。 代码实现: // 在原型链封装一个方法 Array.prototype.unique = function ...
  • js数组去重

    2018-08-08 20:27:27
    // 借助新数组 通过indexOf方判断当前元素在数组中的索引如果与循环的下标相等则添加到新数组中 var arr = [1,23,1,1,1,3,23,5,6,7,9,9,8,5]; function rep(arr) { var ret = []; for (var i = 0; i &lt; arr....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,636
精华内容 1,054
关键字:

js二维数组去重