1.最简要领

建立一个空的新数组，顺次搜检旧数组的值是不是存在于新数组中，假如不存在就push进去。重要用到数组的indexOf要领。

            function arrUnique(arr){
                var newArr = [];
                for (i = 0; i < arr.length; i++){
                    if (newArr.indexOf(arr[i]) == -1){
                        newArr.push(arr[i]);
                    }
                }
                return newArr;
            }
            var arr = [1,2,3,4,5,3,2];
            console.log(arrUnique(arr));

2.对象属性赋值1

经由过程将旧数组的值离别赋值给对象的属性，因为对象属性赋值时旧属性会被新的同名属性掩盖，所以保证了数组（属性）的单一性，末了经由过程for in将这些属性push到新数组中。

        function arrUnique(arr){
            var obj = {};
            var newArr = [];
            arr.map(function(item){
                obj[item] = null;
            })
            for (var key in obj){
                newArr.push(Number(key));
            }
            return newArr;
        }
        var arr = [1,2,3,4,5,3,2];
        console.log(arrUnique(arr));

3 对象属性赋值2

建立一个空数组和空对象，搜检旧数组的值是不是作为对象的属性存在，假如不存在就给这个对象增加数组值属性，属性值为1，而且把这个数组的值赋值给新数组。应用的道理照样对象属性值会被掩盖，也就是说是唯一的。下标的援用要比用indexOf搜刮数组快的多，所以该要领要领2快。此处的对象实际上是一个哈希表，虽然速率快许多，然则内存占用较大，也就是以空间换时候。

        function arrUnique(arr){
            var newArr = [];
            var obj = {};
            for (var i = 0; i < arr.length; i++){
                if (!obj[arr[i]]){
                    newArr.push(arr[i]);
                    obj[arr[i]]=1;
                }
            }
            return newArr;
        }
        var arr = [1,2,3,4,5,3,2];
        console.log(arrUnique(arr));

4 先运用数组的sort要领排序，节约空间且速率较快

先对原数组排序，然后推断数组元素是不是在新数组的末了一名，假如不是就push进去。这类要领比纯真轮回要快许多，虽然没有哈希表体式格局快，然则不占用较大空间。

            function arrUnique(arr){
                arr.sort();//快排
                var newArr = [];
                for(var i = 0; i < arr.length; i++){
                    if (arr[i] !== newArr[newArr.length - 1]){
                        newArr.push(arr[i]);
                    }
                }
                return newArr;
            }
            var arr = [1,2,3,4,5,3,2];
            console.log(arrUnique(arr));

5 来自批评区的好心

昨天宣布该文以后，本日收到批评区 亦秋 的反应，给出了两种很简约的ES6去重体式格局。
1）第一种体式格局是推断数组中的第一索引号即是参数索引号，一般来说，假如数组元素反复，除第一个元素外，一切反复元素的索引和该元素对应的第一索引是差别的。该处第一索引是指自左向右搜刮到的第一个元素的索引号。

[1,2,3,4,5,3,2].filter((value, index, array) => array.indexOf(value) === index)

2）经由过程ES6的Set数据构造，该构造类似于数组，然则不会涌现反复元素，因而，只需基于原始数组建立Set构造，然后在数组内部睁开就成了单一元素数组。

[...new Set([1,2,3,4,5,3,2])]