数组去重最详细的方法

ES6

set方法

第一种 利用set特有的属性将其去重然后用Array.from方法将其转换为数组

  <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = new Set(arr)
        let result = Array.from(newArr)
        console.log(result)
    </script>

第二种 利用set特有的属性将其去重然后用【…】方法将其转换为数组

  <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = new Set(arr)
        let arr1 = [...newArr]
        console.log(arr1)
    </script>

ES6之前

元素对比法

每一个第一次进来的新元素会返回undefined，进入else里面赋值为1，第二次进来的元素会被删除，然后将else里面的数据push入新数组

  <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let content = [];
        let newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (content[arr[i]]) {
                delete content[arr[i]];
            } else {
                content[arr[i]] = 1;
                newArr.push(arr[i]);
            }
        }
        console.log(newArr);
    </script>

定义一个新数组，原数组的第一个元素放到新数组，然后将原数组一一和新数组对比，若不同则push新数组中。

 <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = [arr[0]];
        for (let i = 1; i < arr.length; i++) {
            let flag = false;
            for (let j = 0; j < newArr.length; j++) {
                if (arr[i] === newArr[j]) {
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                newArr.push(arr[i]);
            }
        }
        console.log(newArr);
    </script>

先将原数组排序，在与相邻的进行比较，如果不同则push入新数组。

 <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let content = arr.sort()
        let newArr = [content[0]]
        for (let i = 1; i < content.length; i++) {
            if (content[i] !== content[i - 1]) {
                newArr.push(content[i])
            }
        }
        console.log(newArr);
    </script>

利用数组api

indexOf 和 lastIndexOf 通过查询下标来判断是否相同，二者没有本质区别，一个从头开始找，一个从尾部开始找。

 <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (newArr.indexOf(arr[i]) === -1) {
                newArr.push(arr[i])
            }
        }
        console.log(newArr);;
    </script>

 <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (newArr.lastIndexOf(arr[i]) === -1) {
                newArr.push(arr[i])
            }
        }
        console.log(newArr);;
    </script>

includes 本身是用来判断数组是否含有某元素，返回Boolean值，但定义一个新数组然后与原数组判断则可以达到数组去重的目的。

<script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let newArr = []
        for (var i = 0; i < arr.length; i++) {
            if (!newArr.includes(arr[i])) {
                newArr.push(arr[i])
            }
        }
        console.log(newArr);
    </script>

splice 写两个参数的话第一个参数起始位置，第二个参数是删除的个数，这里的意思如果比较的结果相同，则删掉该元素。

 <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        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);
                }
            }
        }
        console.log(arr);
    </script>

利用对象独有的方法

  <script>
        let arr = [11, 22, 33, 11, 22, 45, 69, 45, 78, 33]
        let obj = {}
        let newArr = []
        for (let i = 0; i < arr.length; i++) {
            if (!obj[arr[i]]) {
                obj[arr[i]] = 1
                newArr.push(arr[i])
            }
        }
        console.log(newArr);
    </script>

终究方法

其实上述的方法很多，但大多都有一个问题，那就是只能对数字进行去重，但是很多数组里面包含的不仅有数字，还可能有字符串，对象，等等一些奇奇怪怪的元素，那么这个时候上述的方法就不可行了，这个时候就要用到对象和数组api结合，达到使一些奇怪的数组去重。

var newArr = [true, true, false, false, undefined, undefined, null, null, obj = { a: 1}, obj = { a: 1}, ‘abcd’, ‘abcd’, ‘1’, ‘1’, 1, 1] ，假设此时有这么一个包含true，false，undefined，null，字符串，对象的数组

 <script>
        var newArr = [true, true, false, false,undefined, undefined, null, null, obj = {
            a: 1
        }, obj = {
            a: 1
        }, 'abcd', 'abcd', '1', '1', 1, 1]

        function unique(arr) {
            var obj = {}
            return arr.filter(function(item, index, array) {
                return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
            })
        }
        console.log(unique(newArr));
    </script>

输出的结果为

可以看到这个这个数组十分的特殊，但还是被去重成功了。这里主要是用到了fitler方法的hasOwnProperty这个方法。filter方法相信大家应该是熟悉的，这里说一下hasOwnProperty() 。官方的解释是 hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。

利用hasOwnProperty（）方法 ，原型 + 值 的写法， 比较的不仅仅是数据类型， 还有值， 再通过对象键名不能重复的特性， 完成了深度去重。