1.新建数组

        var arr=[1,2,3,1,2,3,4,1,2,3,4,5,1,2,3,4,5,6,]
        console.log( setNewArr(arr) );
        // 封装成一个函数的形式
        // 你给我一个数组,我给你一个不重复的新数组
        function setNewArr(array){
            // 先定义一个空数组
            var newArr = [];
            // 循环遍历 原始数组中的所有单元
            // v 就是 每次循环 原始数组array 获取对应单元存储的数据
            // v 一次是 1,2,3,1,2,3,4....
            array.forEach(function(v){
                // 将原始数组的数组,v,写入到新的数组中
                // 需要添加判断, 判断 新数组 newArr 中 没有 v 再执行写入
                // indexOf() 可以 在数组中 查询存储的数据
                // 如果没有这个数据,返回结果是 -1
                // 也就是 在 newArr 中 使用 indexOf() 查询 v
                // 如果结果是 -1 证明 newArr 中 没有 v 
                // 可以执行写入操作
                if( newArr.indexOf( v ) === -1 ){
                    newArr.push(v);
                }
            })
            // 函数的执行结果,返回值,是新的数组
            return newArr;
        }

2.排序删除

最大问题是: 数组的数值顺序,一定会有所改变

        var arr=[1,2,3,'北京',1,2,3,'北京','上海',1,2,3,'北京','上海','广州']
        console.log(setNewArr( arr ) );
        function setNewArr(array){
            // 将数组排序 
            array = array.sort();
            // 数组去重
            // 从第一个单元开始,当前单元 和 下一个单元 进行比较,如果存储的数值相同
            // 就删除之后的单元

            // 当前单元是 i  下一个单元是 i+1
            // 当前单元存储的数据 array[i]   下一个单元的数据是 array[i+1]

            // array.length-1   是 最后一个单元的索引下标
            // 最后一个单元 i+1 没有比较的对象了
            // 倒数第二个单元 i+1 就是最后一个单元的比较了
            for(var i = 0 ; i < array.length-1 ; i++){
                // 定义是全等
                if(array[i] === array[i+1]){
                    // 如果相同,就删除后一个单元
                    // 从 i+1 开始 删除 1个单元
                    array.splice( i+1 , 1 );
                    // 为了 防止  数组坍塌 造成的影响
                    // 就是对 反正 数组删除的单元 再次循环 再次操作
                    // 也就是对 坍塌过来的新的数组,再次执行比较判断操作
                    i--;
                }
            }
            return array;
        }

3.循环嵌套删除

数组排序删除重复的单元,会造成数组中党员顺序的改变,可以使用循环嵌套方法进行避免

        var arr=[ 1,2,3,4,3,2,1,1,2,3,4,5];
        console.log( getNewArr(arr) );
        function getNewArr(array){
            // 外层循环,生成 第一个到 倒数第二个单元 的 索引下标
            for(var i = 0 ; i <= array.length-1-1 ; i++){
                // 内层循环,生成 i 之后的 所有 单元的索引下标
                for(var j = i+1 ; j <= array.length-1 ; j++){
                    // array[i] 是当前的单元 
                    // array[j] 是当前的单元,之后的所有单元 
                    // 如果相等,删除 之后 j 单元
                    if(array[i] === array[j]){
                        array.splice( j , 1 );
                        j--;
                    } 
                }
            }
            return array;
        }

数组的坍塌:

数组 发生 删除单元操作

防止数组坍塌的影响:

核心