js数组去重排序（升序、降序、随机）方法

js原生去重排序

var hhl = [1, 5, 6, 3, 2, 7, 6, 1, 5, 4, 8, 6, 9]
        var newArr = [];//创建一个新数组
        var isRepeat = false;//判断
        for (var i in hhl) {
            isRepeat = false;
            for (var h in newArr) {
                if (newArr[h] == hhl[i]) {
                    isRepeat = true//如果数组的数值相等返回true
                }
            }
            if (!isRepeat) {
                newArr[newArr.length] = hhl[i]
                //不相等的数值放入新的数组
            }
        }
        console.log("去重后的", newArr)
  //冒泡排序
        var temp;
        for (var i = newArr.length; i > 0; i--) {
            for (var j = 0; j < i - 1; j++) {
                if (newArr[j] >newArr[j + 1]) {
                    //>升序 <降序

                    temp = newArr[j];
                    newArr[j] = newArr[j + 1];
                    newArr[j + 1] = temp;
                }
            }
        }
        console.log("去重排序后的", newArr)

利用 for 嵌套 for，然后 splice 去重（ES5 中最常用） 

利用 ES6 Set 去重（ES6 中最常用）推荐(方便） 

注：1.因为Set数据结构并非真正的数组，它类似于数组，并且成员值都是唯一的，没有重复，所以可以用来做去重操作。但是因为它是一个类似数组结构，所以需要转型为真正的数组去使用。所以需要用Array.from

2.如果里面不是一个string类型，而是对象不会去重:所以可以使用JSON.stringify进行转化成string类型，然后就可以用new Set对这个数组进行去重，然后再用Array.from转化为真正的数组。

也可（JSON.parse转化）

利用 indexOf 去重 

利用 sort()去重 

 利用对象的属性不能相同的特点进行去重

利用 includes 去重 

js中使用es6的set数据结构去除数组对象中的重复对象

  //去重
      const noRepeat = [
        ...new Set(this.datainfo.userList.map((item) => JSON.stringify(item)))
      ]
      this.datainfo.userList = noRepeat.map((item) => JSON.parse(item))

数组对象根据属性值去重

    unique(arr) {
      var newArr = [];
      for (var i = 0; i < arr.length; i++) {
        if (!newArr.includes(arr[i])) {
          newArr.push(arr[i]);
        }
      }
      return newArr;
    },

for循环的

let data = [
  {sum:1,data:'20200907'},
  {sum:5,data:'20200906'},
  {sum:8,data:'20200907'},
  {sum:12,data:'20200908'},
]

var arr1 = []
let obj = {}
for(var i = 0;i<data.length;i++){
  if (!obj[data[i].data]) {
    arr1.push(data[i]);
    obj[data[i].data] = true;
    }
}
console.log(arr1)

Es6

function filterArr(Arr,data){

let newarr={};
return Arr.reduce((vlaue,item)=>{

newarr[item[data]] ? '':newarr[item[data]]=true && vlaue.push(item);

return value;
}，[]);


  let data = [
  {sum:1,data:'20200907'},
  {sum:5,data:'20200906'},
  {sum:8,data:'20200907'},
  {sum:12,data:'20200908'},
 ];
function filterArr(Arr, data) {
    let newarr = {};
     return Arr.reduce((ok, item) => {
        newarr[item[data]] ? '' : newarr[item[data]] = true && ok.push(item);
        return ok;
    }, []);
}
let Arr = filterArr(data, 'data');
console.log(Arr);

注 ：如果有多维数组如 [1,[2],[3,[2,3,4,5]] ] 先扁平化再去重,
用Array.flat(Infinity)实现扁平化。

插入排序:

   升序思想: 一般假设前面第一个元素是一个有序序列. 循环后面元素和前面有序序列最后一个元素进行比较，如果后面的元素比有序序列的最后一个元素大，不用挪动位置. 如果后面的元素A比有序序列的最后一个元素小,那么A就应该继续往有序序列的前面查找，找到它应该存放的位置,在这个位置插入元素A。

​​  var numbers = [3, 44, 38, 5, 47, 15, 36, 26, 27];
        for(var i=0;i<numbers.length;i++){
            //取出后面一位的元素 和 前面的有序序列进行对比
            for(var j=i+1;j>0;j--){
                if(numbers[j]<numbers[j-1]){ //后面的元素比有序序列的前一个元素小，交换位置
                    //交换位置
                    var tmp=numbers[j];
                    numbers[j]=numbers[j-1];
                    numbers[j-1]=tmp;
                }else{
                    //如果当前元素没有比前面的小，这个元素在当前位置不动.它已经是有序队列里面最大.
                    break;
                }
            }
        }
        console.log("插入排序的结果==>",numbers);

       var nums = [3, 44, 38, 5, 47, 15, 36, 26, 27];
        //从1开始循环 假设第一个元素是一个有序列表
        for(var i=1;i<nums.length;i++){
            var preIndex=i-1;//代表 有序列表的最后一个元素的下标
            var current=nums[i];//取出当前的值.
            //判断 preIndex 下标大于0 当前值如果比有序列表的最后一个值要小
            while(preIndex>0 && current<nums[preIndex]){
                nums[preIndex+1]=nums[preIndex];//把前面比当前值大的数据往后挪一位
                preIndex--;//继续查找前面的元素 往后面挪.
            }
            //前面已经挪动完成，现在把当前值插入前面位置.
            // XXXXXXXXXXXX 条件不成立的时候 多减了1 所有这里加+1
            nums[preIndex+1]=current;
        }
        console.log("插入排序结果22==》",nums);

 冒泡排序

 规定从小到大排序数组即 升序排列 

思路： 从第一个元素开始，相邻两个元素之间 两两比较，如果前一个值比后一个值大，就交换位置.

方法一：

​​​​     var nums = [25,3,16,36,30,11,42,47,39,20];
        for(var i=0;i<nums.length;i++){
         
            for(var j=0;j<nums.length-i-1;j++){
                if(nums[j]>nums[j+1]){
                    //大于，小于==升序和降序
                    var tmp=nums[j];
                        nums[j]=nums[j+1];
                        nums[j+1]=tmp;
                }
            }
        }
        console.log('另外写法==>',nums);

方法二：

  var numbers = [25,3,16,36,30,11,42,47,39,20];
        var temp;//临时变量
        for(var i=numbers.length;i>0;i--){
            //里面的循环每执行一次就会找到一个最大值
            // for(var j=0;j<numbers.length;j++) 循环100次.
            for(var j=0;j<i-1;j++){// 第一次 查找9次才能找到最大值 第二次只要循环8次就可以找到第二大值.
                if(numbers[j]>numbers[j+1]){//如果当前值比后一个值大就交换位置,把大的值往后面排.
                    //交换位置
                    temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        console.log(numbers);

方法三：

/降序而且用 while循环实现.
        var numbers2 = [25,3,16,36,30,11,42,47,39,20];
        var x=numbers2.length;
        while(x>0){
            var y=0;
            while(y<x-1){
                if(numbers2[y]<numbers2[y+1]){ //判断前一个元素比后一个小 交换位置
                    var t=numbers2[y];
                    numbers2[y]=numbers2[y+1];
                    numbers2[y+1]=t;
                }
                y++;
            }
            x--;
        }
        console.log("numbers2==>",numbers2)

数组的随机排序

方法一：

   var arr =[1,2,3,4,5,6,7,8,9,10];
        function randSort1(arr){

            for(var i=0,len=arr.length;i<len;i++){
                var rand=parseInt(Math.random()*len);
                var temp=arr[rand];
                arr[rand]=arr[i];
                arr[i]=temp;
            }
            return arr;

        }
        console.log(randSort1(arr))

方法二（简洁）：

   var arr =[1,2,3,4,5,6,7,8,9,10];
        arr.sort(function(){
            return Math.random()-0.5;
        })
        console.log(arr)

方法三：

        var arr =[1,2,3,4,5,6,7,8,9,10];
        function randSort2(arr){
            var num=[];
            while(arr.length>0){
                var randoms=parseInt(Math.random()*arr.length);
                num.push(arr[randoms]);
                arr.splice(randoms,1);
            }
            return num;
        }
        console.log(randSort2(arr))