数组的去重

第一种

• indexOf 方法用于检索一个数组里面是否有对应的元素；
• 如果有，返回对应的索 引值，下标从 0 开始；如果没有，返回-1;
• 可以使用指定下标(数组的长度)、push、unshift 等方式把不存在的元素追加到新数组里面

        num = [1,2,3,2,1,5,3,5];
        var newarr=[];
        for (let i = 0; i < num.length; i++) {
            if(newarr.indexOf(num[i]) == -1){
                newarr.push(num[i])
            }
        }
        console.log(newarr);

函数封装

        function unique(arr) {
            if (!Array.isArray(arr)) {
                console.log('type error!')
                return
            }
            var array = [];
            for (var i = 0; i < arr.length; i++) {
                if (array.indexOf(arr[i]) === -1) {
                    array.push(arr[i])
                }
            }
            return array;
        }

第二种

利用ES6的Set去重

        function unique(arr){
            return Array.from(new Set(arr))
        }
        let arr = [1,2,3,2,1,5,3,5];
        console.log(unique(arr));

第三种

• 双重for循环
• i从0循环，j从1循环
• arr.splice(j,1) 如果arr[i]=arr[j] 那么在数组中从j删除，删一个
• j--
• 一次循环就将外层循环的arr[i]在数组中的所有相同元素全删除掉

        function unique(arr){
            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--;
                    }
                }
            }
            return arr;
        }
        console.log(unique([1,2,3,2,1,5,3,5]));

第四种

利用includes去重 和第一种类似，只是将数组方法indexOf和includes做个复习 返回值不同，一个 -1一个false，总的来说都是做个判断。

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

第五种

1. 数组的filter(func,thisArg)方法用来创建一个新数组，数组的元素包含了那些原数组中通过测试函数的元素。

• func：测试函数，如果元素满足测试函数的条件，则返回true，否则返回false。该函数接受三个参数，分别是数组元素，元素的索引和数组本身。
• thisArg：测试函数中引用的this对象。如果未指定，在严格模式下指向undefined，非严格模式下指向全局对象。

2. 对象的hasOwnProperty() 方法。返回一个布尔值，指示对象自身属性中是否具有指定的属性。

        function unique(arr) {
            var obj = {};
            return arr.filter(function (item, index, arr) {
                return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item +item] = true)
            })
        }

第六种

利用filter

        function unique(arr) {
            return arr.filter(function (item, index, arr) {
                //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
                return arr.indexOf(item, 0) === index;
            });
        }
        console.log(unique([1, 1, 2, 2]))

第七种

利用Map

        function unique(arr) {
            let map = new Map();
            let array = new Array(); // 数组用于返回结果
            for (let i = 0; i < arr.length; i++) {
                if (map.has(arr[i])) { //
                    map.set(arr[i], true);
                } else {
                    map.set(arr[i], false); // 如果没有该 key 值
                    array.push(arr[i]);
                }
            }
            return array;
        }

第八种

利用reduce+includes

        function unique(arr) {
            return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur],
                []);
        }

第九种

Set

        let arr = [1,2,3,2,1,5,3,5];
        console.log [...new Set(arr)]