第一种：

function deRepeat(arr){
       var newArr=[];
       for(var i=0;i<arr.length;i++){
           if(newArr.indexOf(arr[i])==-1){//如果新的数组中没有这个值，就将其添加到新的数组中
               newArr.push(arr[i]);
           }
       }
       return newArr;
   }
   var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
  // var str = arr.join();
console.log(deRepeat(arr));//[1, 2, 34, 23, {a:1},{b:1},[],[]]

indexOf() 方法可返回某个指定元素在数组中首次出现的位置。如果在数组中没找到指定元素则返回 -1。（该方法不支持IE8及更早的IE版本）

第二种

function deRepeat(arr){
     var newArr = [];
     arr.forEach(function(e,index,arr){
        if(arr.indexOf(e)==index){//如果该值是第一次出现，则将其添加到新的数组中
            newArr.push(e);
        }
     })
     return newArr;
 }
 var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
 console.log(deRepeat(arr));//[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]]

forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。

array.forEach(function(currentValue, index, arr), thisValue)

参数

参数

描述

function(currentValue, index, arr)

必需。 数组中每个元素需要调用的函数。

函数参数:


thisValue

可选。传递给函数的值一般用 "this" 值。

如果这个参数为空， "undefined" 会传递给 "this" 值

参数

描述

currentValue

必需。当前元素

index

可选。当前元素的索引值。

arr

可选。当前元素所属的数组对象。

第三种

function deRepeat(arr){
     var newArr = arr.filter(function(e,index,arr){
        return arr.indexOf(e)==index;
     })
     return newArr;
 }
 var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
 console.log(deRepeat(arr));//[1,2,34,23,{a:1},{b:1},[],[]]

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

filter()方法的用法和forEach()方法差不多，此处就不再详细赘述了。

第四种

function deRepeat(arr){
    var newArr=[];
    var temp;
    arr.sort();
    newArr.push(arr[0]);
    for(var i=1; i<arr.length;i++){
        if(arr[i]!=temp){
            newArr.push(arr[i]);
            temp= arr[i];
        }
    }
    return newArr;
}
 var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
 console.log(deRepeat(arr));//[[],[],1,2,23,34,{a:1},{b:1}]

利用数组的排序方法，先将数组进行排序，然后与temp进行比较

第五种

function deRepeat(arr){
    for(var i=0; i<arr.length; i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]==arr[j]){
                arr.splice(j,1);
                j--;
            }
        }
    }
    return arr;
}
 var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
 console.log(deRepeat(arr));//[1,2,34,23,{a:1},{b:1},[],[]]

利用数组中的splice()方法,以及for循环的嵌套


第六种

function deRepeat(arr){
    let newArr=[];
    const set = new Set(arr);
    newArr = [...set];
    return newArr;
}
 var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
 console.log(deRepeat(arr));//[1,2,34,23,{a:1},{b:1},[],[]]

主要利用的是ES6中的set数据结构（由一组无序且唯一的项组成），以及扩展运算符...

第七种，主要利用ES6中的set数据结构，以及Array.from()方法

function deRepeat(arr) {
  return Array.from(new Set(array));
}
var arr = []
console.log(deRepeat([1, 1, 2, 3])) //

Array.from()方法可以将 Set 结构转为数组。



第八种，遍历数组，利用object对象保存数组值，判断数组值是否已经保存在object中，未保存则push到新数组并用object[arrayItem]=1的方式记录保存

但是只适合数组中是基本数据类型的情况，对于数组里面是引用类型数据的情况不适用，看下面的打印结果就知道了

function deRepeat(arr){
      var obj = {};
      var newArr = [];
      for(var i=0;i<arr.length;i++){
          if(!obj[arr[i]]){
              obj[arr[i]] = 1;
              newArr.push(arr[i]);
          }
      }
      return newArr;
  }
  var arr=[1,2,1,2,34,2,23,23,23,{a:1},{b:1},[],[]];
  console.log(deRepeat(arr));//[1, 2, 34, 23, {a:1},[]]