数组去重

数组去重的十三种方法

Set (ES6中常见)Set中存放的数据都是不会重复的数据

    let arr1 = new Set([20, 20, 30, 'aa', 'aa', 4, 4, 5, 5])
    console.log(arr1) //Set(5) {20, 30, 'aa', 4, 5}

[...new Set()]

    let arr2 = [1, 2, 2, 'aa', 'aa', 3, 3, 4, 4]
    arr2 = [...new Set(arr2)]
    console.log(arr2)

Set + Array.from

Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组

    let arr1 = new Set([20, 20, 30, 'aa', 'aa', 4, 4, 5, 5])

    function newArr(arr1) {
        return Array.from(new Set(arr1))
    }
    console.log(newArr(arr1)) //((5) [20, 30, 'aa', 4, 5]

indexOf()

该方法可返回某个指定的字符串值在字符串中首次出现的位置,如果不存在，则返回-1

    let arr3 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
        let ary = [];
        for (let i = 0; i < arr3.length; i++) {
            let d = arr3[i]
            if (ary.indexOf(d) == -1) {
                ary.push(arr3[i])
            }
        }
    console.log(ary) //(5) [1, 2, 'aa', 'b', 4]

filter() + indexOf()

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

     let arr4 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];
        function unique(a) {
            let res = a.filter(function(item, index, array) {
                /**
                 item:必须,当前元素的值
                 index:可选。当前元素的索引值
                 array:可选。当前元素属于的数组对象
                 **/ 
                return array.indexOf(item) === index;
            });
            return res;
        }
        unique(arr4);
        console.log(arr4) //(5) [1, 2, 'aa', 'b', 4]

双重for循环+splice (splice() 方法用于添加或删除数组中的元素。)

双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。

      let arr5 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];

        function unique(ary) {
            for (let i = 0; i < ary.length; i++) {
                for (j = i + 1; j < ary.length; j++) {
                    if (ary[i] === ary[j]) {
                        ary.splice(j, 1);
                        j--;
                    }
                }
            }
            return ary;
        }
        unique(arr5);
        console.log(arr5) //[1, 2, 'aa', 'b', 4]

sort()

利用 sort() 排序方法，然后根据排序后的结果进行遍历及相邻元素比对。

    let arr6 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];

            function unique(ary) {
                let a = ary.sort(function(a, b) {
                    return a - b;
                });
                for (let i = 0; i < a.length; i++) {
                    if (a[i] === a[i + 1]) {
                        a.splice(i + 1, 1);
                        i--;
                    }
                }
                return a;
            }
            unique(arr6)
            console.log(arr6) // [1, 2, 'aa', 'b', 4]

includes() 用于判断字符串是否包含指定的子字符串。

如果找到匹配的字符串则返回 true，否则返回 false。

    let arr7 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]

            function unique(ary) {
                let newAry = [];
                let len = ary.length;
                for (let i = 0; i < len; i++) {
                    let cur = ary[i];
                    if (!newAry.includes(cur)) {
                        newAry.push(cur);
                    }
                }
                return newAry;
            }
            console.log(unique(arr7)); //[1, 2, 'aa', 'b', 4]

Map

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。

    let arr8 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]

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

reduce

    let arr9 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];

        function unique(ary) {
            // reduce : 第一个是函数，第二个参数会传给第一次回调的prev;
            return ary.reduce((prev, next) => {
                // 该函数返回值是下一次执行的prev;
                return prev.includes(next) ? prev : [...prev, next];
            }, [])
        }
        console.log(unique(arr9)); //[1, 2, 'aa', 'b', 4]

hasOwnProperty 检测属性名对象的一个私有属性；返回一个布尔值

    let arr10 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4];

        function unique(ary) {
            let obj = {};
            return ary.filter(function(item, index, a) {
                // item : 数组每一个成员
                // index: 成员对应的索引
                // a : 整个数组
                // hasOwnProperty来校验的该属性是否出现过；
                return obj.hasOwnProperty(typeof item + item) ? false : obj[typeof item + item] = true;
                if (obj.hasOwnProperty(typeof item + item)) {
                    return false
                } else {
                    obj[typeof item + item] = true;
                    return true;
                }
            })
        }
        console.log(unique(arr10)) // [1, 2, 'aa', 'b', 4]

递归

    let arr11 = [1, 2, 2, 'aa', 'aa', 'b', 'b', 4, 4]

            function unique(ary) {
                let len = ary.length;
                //排序后更加方便去重
                ary = ary.sort(function(a, b) {
                    return a - b;
                });

                function loop(index) {
                    if (index >= 1) {
                        if (ary[index] === ary[index - 1]) {
                            ary.splice(index, 1);
                        }
                        //递归loop，然后数组去重
                        loop(index - 1)
                    }
                }
                loop(len - 1);
                return ary;
            }
            console.log(unique(arr11)) //(5) [1, 2, 'aa', 'b', 4]

利用对象属性名不能重复的方法。（不适合引号包裹的数字）

    let arr12 = [1, 2, 'aa', 'aa', 'b', 'b', 4, 4, '2']

            function unique(ary) {
                if (ary instanceof Array) {
                    let newAry = [];
                    let obj = {};
                    // 不适合区分数组项是字符型的数字，例如：2与‘2‘,
                    for (let i = 0; i < ary.length; i++) {
                        let cur = ary[i];
                        obj[cur] = cur;
                    }
                    //把对象的属性名放到新数组中
                    for (let key in obj) {
                        newAry.push(obj[key]);
                    }
                    return newAry;
                }
            }
            console.log(unique(arr12)) //[1, '2', 4, 'aa', 'b']