将数组去重排序

js数组去除重复数据

JavaScript数组去重（12种方法，史上最全） - SegmentFault 思否 JavaScript数组去重（12种方法，史上最全）

if（）continue语句的作用是：如果满足if里面的条件，则不执行循环语句里面的剩余内容，跳出循环，执行下一次循环。

当i为0,2,4,6,8时，满足i%2==0的条件，执行continue语句，进入下次循环，不会执行printf语句。

vue 数组对象去重：

//this.phoneList = this.unique(that.phoneList)
let arrs = this.itemIds.concat(this.itemIds2); //数组合并
this.newtableData = this.unique(arrs); //数组去重

unique(arr) {
  const res = new Map();
  return arr.filter((arr) => !res.has(arr.id) && res.set(arr.id, 1))
}
//reduce
let arr = [
            {
                key:'1',
                name:'林青霞'
            },
            {
                key:'2',
                name:'张三丰'
            },
            {
                key:'1',
                name:'段誉'
            },
            {
                key:'3',
                name:'林青霞'
            },
        ]

let obj = {}
        let res = arr.reduce(function(preValue,item){
            console.log(preValue,'--')//上一次调用回调返回的值，或者是提供的初始值
            console.log(item,'++')//下一个要遍历的数组成员
            // 下面这句话是首先是判断当前数组成员的key是否存在于obj中，如果已经存在，将这个obj中的key设置为空，并且值设置为true，再将当前数组成员添加到返回值中
            // 如果不存在，obj中的key为当前数组成员的key，并且值设置为true，再将当前数组成员添加到返回值中
            obj[item.key] ? '' : obj[item.key] = true && preValue.push(item);
            console.log(obj,'obj2')
            return preValue
        },[])//将返回值的初始值定义为空数组

        // 封装方法:根据提供的属性去重
        function arrDistinctByProp(arr,prop){
            let obj = {};
            return arr.reduce(function(preValue,item){
                obj[item[prop]] ? '' : obj[item[prop]] = true && preValue.push(item);
                return preValue
            },[])
        }
        // 根据name去重
        let newArr = arrDistinctByProp(arr,'name')
        // 打印返回的新数组
        console.log(newArr)


//filter
let arr = [
            {
                key:'1',
                name:'林青霞'
            },
            {
                key:'2',
                name:'张三丰'
            },
            {
                key:'1',
                name:'段誉'
            },
            {
                key:'1',
                name:'段誉'
            }
        ]

        let res = arr.filter(function(item,index,self){
            return self.findIndex(el=>el.key==item.key)===index
        })
        console.log(res,'===')

        // 封装方法:根据提供的属性去重
        function arrDistinctByProp(arr,prop){
            return arr.filter(function(item,index,self){
                return self.findIndex(el=>el[prop]==item[prop])===index
            })
        }
        //通过name属性去重
        let res = arrDistinctByProp(arr,'name')
        console.log(res,'===')

一句话数组去重
    Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
    let arr = [1,2,3,4,5,1,2,3]
    let arr2 = Array.from(new Set(arr))
    console.log(arr2) //[1,2,3,4,5] 
 
    let arr = [1,1,2,22,2,5,null,5]	
    arr2 = [...new Set(arr)] //简化写法
    console.log(arr2)//1 2 22 5 null

    let arr2 = new Set(arr)  
	console.log(...arr2)//1 2 22 5 null

function unique (arr) {
  return Array.from(new Set(arr))
}
var arr = [1,1,'true',true,15,false,false, undefined,undefined, null, NaN,NaN,'NaN'];
console.log(unique(arr))

reduce数组去重

let arr = [1,2,3,4,4,1]
let newArr = arr.reduce((pre,cur)=>{
    if(!pre.includes(cur)){
      return pre.concat(cur)
    }else{
      return pre
    }
},[])
console.log(newArr);// [1, 2, 3, 4]

 将数组去重重新排序的简便方法

<script type="text/javascript">
//第一种只比较不排序
/*var arr =[1,2,2,3,4,6,2,3,7,8]
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--;
		}
	}
}
console.log(arr);*/

//第二种好的方法:去重重新排序
//定义一个比较函数，让数字从大到小排序
  function Compare(a,b){
    if(a>b){
      return 1;
    }else if(a<b){
      return -1;
    }else{
      return 0;
    }
  }
  var a = [1,2,3,4,5,"2","1",99,107];
  var b = a.sort(Compare);
  console.log(b);
  var newArray = [b[0]];
  for(var i=1;i<b.length;i++){
    if(b[i] !=newArray[newArray.length-1]){
      newArray.push(b[i]);
    }
  }
  console.log(newArray);
</script>