JavaScript中数组去重（逆战班）

数组去重

        方法1: indexOf()
               建立一个新的数组,将原始数组的数值,写入到新数组中
               如果新数组中没有这个数值的存在,再写入
               indexOf() 判断 结果 是 -1 
        方法2: 双重for循环
               外层从第一个数值循环至最后一个数值
                  内层是从外层循环数值的下一个数值开始,循环至最后一个数值
                      比较外层循环的数值和内层循环的数值
                      如果数值相同,就是删除内层循环表示的数组单元
                      要做 内层循环遍历--操作,防止数组坍塌造成的影响
        方法3: 一层for循环
               将数组进行排序,让相同的数据都相邻
               相邻的两个数值比较,如果数值相同,就删除后面的单元
               要做 循环变量--操作,防止数组坍塌造成的影响
        方法4: 利用对象的特性
               相同属性名,只能建立一个对象单元
               重复的属性名是做单元更新操作,而不是新建单元操作
               数组的数据 --- 对象的属性名 --- 数组的数据

1,indexOf()

     将原始数组中的数据,写入到新的数组中
     如果新数组中,没有这个数据,我们再进行写入操作
     indexOf() 结果是 -1 

    var arr = [1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6];

    var arr2 = setNewArr(arr);

    console.log(arr2);

    // 参数是需要执行去除重复数据的数组

    function setNewArr(arr){
        var newArr = [];
        arr.forEach(function(val){
            if( newArr.indexOf(val) == -1 ){
                newArr.push(val);
            }
        })

        return newArr;
    }

2,双重for循环()

     使用双层for循环,来完成对数组中数值的比较
     如果数值相同,就删除其中一个数值
     从第一个数值开始循环,第一个数值和其后的所有数据进行比较
     如果要是数值相同,就删除之后的数值
     循环次数比较多

    var arr123 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5];
    function setNewArr2(arr){
        // 外层循环,从第一个数值开始,循环至最后一个数值
        for(var i = 0 ; i <= arr.length-1 ; i++){
            // 内层循环,从当前起始数值的下一个数值开始,循环至最后一个数值
            for(var j = i+1 ; j <= arr.length-1 ; j++){
                if(arr[i] === arr[j]){
                    // 执行删除数组单元操作,之后的单元,会前移,顶替当前位置的单元
                    // 此时,当前位置就是放置了一个新的单元
                    // 这个位置就必须要重新操作一次,判断数值是否相同
                    arr.splice(j,1);
                    // 先将循环生成的索引--, 在执行循环的++
                    // 等于操作之后,索引值没有变,下次循环,执行的对象,仍然是当前这个单元
                    j--;
                }
            }
        }         

        return arr;
    }

    var newArr = setNewArr2(arr123);

    console.log(newArr);

3,一层for循环
先将数组中的数值,按照大小顺序,排列
排序之后,相同的数值,一定是相邻的
此时,只要相邻的两个数值比较,如果相同,删除后一个数据,再执行 i–
使用一层循环就可以了
循环次数就比较少

    var arr = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5];

    var newArr = setNewArr3(arr);
    console.log(newArr);


    function setNewArr3(arr){
        // 先对数组进行排序操作,相同数据,相邻
        var newArr = arr.sort(function(a,b){return a-b});
        console.log(newArr);
        // 当前数据与下一个数据比较
        // 冒泡排序的优化原理:只要循环到倒数第二个单元
        // 就会通过i+1 与最后一个单元比较
        // 比较到最后一个单元,循环只要执行到,倒数第二个单元
        for(var i = 0 ; i <= newArr.length-1 -1 ; i++){
            if(newArr[i] === newArr[i+1]){
                // 删除后一个单元
                newArr.splice(i+1 , 1);
                // 防止数组坍塌,造成有单元没有执行操作
                i--;
            }
        }
        return newArr;
    }

4,利用对象的特性

    // 利用对象的属性,来完成数组去重
    // 对象的属性特点:一个对象中,相同的键名,只能建立一个
    // 再对已经存在的键名进行赋值,是修改数据操作

    // 数组中,已经有两个单元,所以是0,1
    // 新建立单元,索引就不能是 0,1
    var arr = ['北京','上海'];
    console.log(arr);

    var obj = {name:'张三'};
    // 不会新建一个对象中的单元,键名是name
    // 会将李四数据,覆盖以后的name键名存储的数据
    obj.name = '李四';
    console.log(obj);


    // 数组去重的思路
    // 利用对象的属性
    // 循环遍历数组,将数组的数值获取,作为对象的键名来赋值
    // 循环遍历之后,对象中,所有键名就是数组中的不重复数据
    // 再循环遍历对象,将对象的键名获取,写成数组的数据

    var arr1 = [1,1,1,1,2,2,2,3,3,3,4,4,4,4,5,5,5];
    console.log(arr1);

    // 获取第一个单元的数值1,作为对象的键名,建立一个单元
    // var obj1 = { 1:'随便' };
    // 获取第二个单元的数值,还是1,还作为对象的键名
    // 此时1键名已经存在,会执行覆盖操作,不会新增一个单元
    // obj1 = { 1:'随便' };
    // console.log(obj1);

    var obj1 = {};
    var newArr = [];

    arr1.forEach(function(val){
        obj1[val] = '老婆,我爱你~~~';
    })

    console.log(obj1);

    // for...in循环对象,自定义变量中存储的是对象单元的属性
    for(var attr in obj1 ){
        // 将属性attr存储的数据写入新数组中
        newArr.push(attr);
    }
        
    console.log(newArr);