精华内容
下载资源
问答
  • php的二维数组去重,数据结构重建和js数组去重最简方法
  • js数组去重

    2020-11-30 16:11:01
    js数组去重

    一、利用ES6 Set去重(ES6中最常用)

    var arr = [1,1,8,8,12,12,15,15,16,16];
    function unique (arr) {
      return Array.from(new Set(arr))
    }
    console.log(unique(arr))
     //[1,8,12,15,16]
    

    不考虑兼容性,这种去重的方法代码最少。这种方法还无法去掉“{}”空对象,后面的高阶方法会添加去掉重复“{}”的方法。

    二、利用for嵌套for,然后splice去重(ES5中最常用)

    var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
    
    function unlink(arr) {
        for (var i = 0; i < arr.length; i++) {    // 首次遍历数组
            for (var j = i + 1; j < arr.length; j++) {   // 再次遍历数组
                if (arr[i] == arr[j]) {          // 判断连个值是否相等
                    arr.splice(j, 1);           // 相等删除后者
                    j--;
                }
            }
        }
        return arr
    }
    console.log(unlink(arr));
    

    //NaN和{}没有去重,两个null直接消失了
    双层循环,外层循环元素,内层循环时比较值。值相同时,则删去这个值。
    想快速学习更多常用的ES6语法,可以看我之前的文章《学习ES6笔记──工作中常用到的ES6语法》。

    3、利用indexOf去重

    var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
    function unlink(arr) {
        if (!Array.isArray(arr)) {
            console.log('错误!')
            return
        }
        var array = [];
        for (var i = 0; i < arr.length; i++) {    // 首次遍历数组
            if (array.indexOf(arr[i]) === -1) {   // 判断索引有没有等于
                array.push(arr[i])
            }
        }
        return array
    }
    console.log(unlink(arr));
    

    //NaN、{}没有去重
    新建一个空的结果数组,for 循环原数组,判断结果数组是否存在当前元素,如果有相同的值则跳过,不相同则push进数组。

    4、利用includes

    var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
    function unique(arr) {
        if (!Array.isArray(arr)) {
            console.log('type error!')
            return
        }
        var array =[];
        for(var i = 0; i < arr.length; i++) {
                if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
                        array.push(arr[i]);
                  }
        }
        return array
    }
    console.log(unique(arr))
    

    5、利用filter

    var arr = [1, 1, 8, 8, 12, 12, 15, 15, 16, 16];
    function unlink(arr) {
        return arr.filter(function (item, index, arr) {
            //当前元素,在原始数组中的第一个索引==当前索引值,否则返回当前元素
            return arr.indexOf(item, 0) === index;
        });
    }
    console.log(unlink(arr));
    
    展开全文
  • JavaScript数组去重

    2021-04-10 23:35:53
    JavaScript数组去重

    JavaScript数组去重

    一.前言

    如今网页开发大部分公司都采用前后端分离进行开发,后端仅仅提供数据,由前端进行处理并渲染。因此数据的处理已经成为前端开发人员必须掌握的技术。数据的存储一般会采用json对象或者数组的形式进行保存,所以笔者在这里介绍一下关于数组的去重。

    数组去重的实现方式有很多,我们可以使用数组的过滤函数(filter)以及set集合进行去重。

    1. Array.prototype.filter()

    let arr = [1, 1, 1, 2, 3, 4, 5, 67, 7, 7, 7];
    
    function quhcong(arr) {
    	return arr.filter((item, index) => {
    		return arr.indexOf(item) === index
    	})
    }
    console.log(quhcong(arr))
    

    我们都知道数组的**filter()**传递一个函数,返回 执行结果为true的一项,如果当前item的索引跟数组中第一次出现这个值的索引不一样时,说明该项就是重复的,所以返回的是false。因此达到了一个去重的 目的。

    2.set()去重

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

    Set集合有一个特性就是集合中的所有元素都是不重复的,它可以接收一个数组作为参数,返回一个set实例对象,这个对象中保存了去重之后的所有元素,然后我们将set集合转换成数组即可。

    展开全文
  • js 数组去重

    2020-10-12 16:06:19
    js 数组去重js 数组去重1、forEach、indexOf2、forEach、includes3、forEach、对象属性存在4、filter删选5、ES6的Set结构、Array.from方法 js 数组去重 1、forEach、indexOf 利用数组原型对象上的forEach方法遍历,...

    js 数组去重

    1、forEach、indexOf

    利用数组原型对象上的forEach方法遍历,indexOf方法筛选

    arrayUnique (arr) {
      const newArr = []
      arr.forEach(item => {
        if (newArr.indexOf(item) === -1) {
          newArr.push(item)
        }
      })
      return newArr
    }
    
    // 简洁写法
    arrayUnique (arr, newArr = []) {
      arr.forEach(item => newArr.indexOf(item) === -1 ? newArr.push(item) : '')
      return newArr
    },
    

    2、forEach、includes

    利用数组原型对象上的forEach方法遍历,includes方法筛选

    arrayUnique2 (arr) {
      const newArr = []
      arr.forEach(item => {
        if (!newArr.includes(item)) {
          newArr.push(item)
        }
      })
      return newArr
    }
    
    // 简洁写法
    arrayUnique2 (arr, newArr = []) {
      arr.forEach(item => !newArr.includes(item) ? newArr.push(item) : '')
      return newArr
    },
    

    3、forEach、对象属性存在

    forEach方法遍历,再借助对象属性存在的特性,如果不存在则放入新数组

    arrayUnique3 (arr) {
      const obj = {}
      const newArr = []
      arr.forEach(item => {
        if (!obj[item]) {
          obj[item] = 1
          newArr.push(item)
        }
      })
      return newArr
    }
    
    // 简洁写法
    arrayUnique3(arr, obj = {}, newArr = []) {
      arr.forEach(item => !obj[item] ? (() => { obj[item] = item; newArr.push(item) })() : '') // 自执行匿名函数
      return newArr
    },
    

    4、filter删选

    利用数组原型对象上的filter进行删选

    arrayUnique4 (arr) {
      return arr.filter((item, index) => arr.indexOf(item) === index)
    }
    

    5、ES6的Set结构、Array.from方法

    创建成员值唯一的Set结构的实例并利用ES6的Array.from转换为数组

    arrayUnique5 (arr) {
      return Array.from(new Set(arr))
    }
    
    展开全文
  • JavaScript 数组去重

    2020-12-25 10:18:23
    数值数组去重 对象数组去重

    数组去重

    1. 利用ES6中的Set去重

    注意点:

    • 语法最简,要考虑兼容问题,是否支持ES6语法
    • 无法判断对象,可以结合下面的对象去重使用
        let arr = [ 1,1, 'true','true',true,true, 15,15, false,false, undefined,undefined,
                    null,null, NaN, NaN, 'NaN', 0, 0, 'a', 'a', {}, {} ];
    
        console.log([...new Set(arr)]);      // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]
    
    

    2. 双重for循环,用splice去重

    注意点:

    • 无法判断NaN和对象
    	for (let i=0; i<arr.length; i++) {
    	    for (let j=i+1; j<arr.length; j++) {
    	        if (arr[i] === arr[j]) {
    	            arr.splice(j, 1);
    	            j--;
    	        }
    	    }
    	}
    	console.log(arr); // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {}, {}, {name: '小明'}, {name: '小明'}]
    
    

    3. 空数组[ ] + indexOf去重

    注意点:

    • 无法判断NaN和对象
          let temp = [];
    
          arr.forEach(item => {
      		temp.indexOf(item) === -1 && temp.push(item);
    	  });
    
          console.log(temp); // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {}, {}, {name: '小明'}, {name: '小明'}]
    
    

    数组对象去重

    用filter和findIndex

    	const objectArr = [
            {id: 1, name: '小明'},
            {id: 2, name: '小红'},
            {id: 1, name: '小李'},
        ];
    
        const filterArr = objectArr.filter((item, index, arr) => arr.findIndex(cItem => cItem.id === item.id) === index);
        console.log(filterArr); // [{id: 1, name: "小明"}, {id: 2, name: "小红"}]
    

    完全的数组去重

    上面方法搭配使用,判断是否为对象类型,是就执行对象去重

    展开全文
  • JS数组去重

    2021-08-13 20:20:11
    JS数组去重 这篇文章归纳了几个常用的数组去重的方法,如果还有其他方法欢迎各位读者在评论区留言 方案一: 有一个叫做Set的数据结构,是一个类似数组的结构 这个数据结构不接收重复数据 语法:new Set(数组) ...
  • 主要介绍了javascript数组去重方法,通过2个示例对比分析了javascript数组去重的原理与操作技巧,需要的朋友可以参考下
  • 主要介绍了详解javascript数组去重问题,根据面试时做的一道数组去重问题的解题思路整理的,分享给大家。
  • javascript数组去重

    2019-10-27 16:42:49
    数组去重在面试和工作中都是比较容易见到的问题,在这里我们介绍一些数组去重的方法,和大家一起分享一下,如果有的地方不对,大家可以指出来,共同学习。 方法一:使用双重for循环 这个方法是非常经典的一个数组...
  • 简单数组去重 对象数组去重 简单数组去重 function arrDistinct(arr){ const newArr = new Set(arr); return [...newArr] } 使用范例 let list = [1,2,2,3,4,4] console.log(arrDistinct(list)) 对象...
  • Js数组去重

    2020-11-10 12:02:22
    Js数组去重 1.问题 数组去重是我么一直都会遇到的问题,网上也很多对于这方面的解决问题,如果是一些简单的数据,我们可以使用 set数据结构 或 for循环+if等判断 或 Array.filter 等等,常规的方式还是挺多的,但是...
  • 主要介绍了javascript数组去重终极总结,本文列举了3种javascript数组去重方法,并分别分析了它们的优缺点,需要的朋友可以参考下
  • js代码-js数组去重

    2021-07-16 15:38:44
    js代码-js数组去重
  • js代码-JS数组去重

    2021-07-16 13:44:15
    js代码-JS数组去重

空空如也

空空如也

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

js数组去重