数组去重（多解）

哈希表思想（最高性能）

思路：新建一个result数组，一个存储标志的对象hash，遍历原数组，对象item对应的值为true时不重复添加，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
   let result = [],hash = {} //定义新数组和hash
   for (const item of arr) {
    /* 遍历前四个数时，hash表中没有这四个值，所以if语句成立，将数据push到result中，令这些表中的数都为true */
       if(!hash[item]) {
           /* 当遍历第二个1时，之前已经令hash[item] = true，所以if语句就不执行了，就不会重复了 */
           result.push(item)
           hash[item] = true //作为一个是否在数组中存在的标志
       }
   }
   return result
}

let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

indexOf()

思路：新建一个result数组，遍历原数组，当item不存在于新数组中，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    let result =[]
    for (const item of arr) {
        if(result.indexOf(item) == -1) {   //indexOf等于-1时代表数组中没有该值
            result.push(item)
        }
    }
    return result
}

let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

includes

思路：新建一个result数组，遍历原数组，当item不存在于新数组中，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    let result = []
    for (const item of arr) {
        !result.includes(item) && result.push(item)
    }
    return result
}

let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

数组下标判断

思路：新建一个result数组，遍历原数组，利用indexOf返回的始终是第一个相同数值的下标,如果新增的内容在原来数组中的下标和现在的下标不同，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    let result = []
    for (let i = 0; i < arr.length; i++) {
        if(arr.indexOf(arr[i]) === i) {   //下标不同，代表重复
            result.push(arr[i])
        }      
    }
    return result
}
let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

双层for循环1

思路：新建一个result数组，两层循环遍历，有重复值时终止当前循环i，进入外层循环i+1；找到的是往后遍历不会有重复值的值，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    let result = []
    for (let i = 0; i < arr.length; i++) {
       for (let j = i+1; j < arr.length; j++) {
           if(arr[i] === arr[j]) {
               ++i
           }           
       }  
       result.push(arr[i])   
    }
    return result
}
let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));  //输出顺序不同

双层for循环2

思路：新建一个result数组，两层循环遍历，有重复值时终止当前循环i，进入外层循环i+1；重复值用splice()删除，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    let result = []
    for (let i = 0,len = arr.length ;i < len; i++) {
       for (let j = i+1; j < len; j++) {
           if(arr[i] === arr[j]) {
               arr.splice(j,1)
               //splice会改变原数组的长度，所以要将数组长度len和下标j减1
               len--
               j--
           }           
       }  
       result.push(arr[i])   
    }
    return result
}
let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

排序去重

思路：新建一个result数组，给数组排序，排序后相同的值会相邻，遍历排序后的数组时，新数组只加入不与前一值重复的值，就添加push进新数组，得到的新数组就是不重复的

function unique(arr) {
    arr.sort()
    let result = [arr[0]]
    for (let i = 1; i < arr.length; i++) {
       /*  if(arr[i] != result[result.length - 1]) {
            result.push(item)
        } */
        arr[i] != arr[i-1] && result.push(arr[i])
    }
    return result
}
let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

es6的Array.filter()

思路：利用Array.filter()方法的过滤方法，将数组进行过滤，筛选条件是数组下标与检索下标一致 ， Array.filter() 通过检查指定数组中符合条件的所有元素；不糊改变原始数组，创建一个新的数组

function unique(arr) {
    return arr.filter((item,index) => {
        return arr.indexOf(item) === index
    })
}

let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));

es6的set结构(高性能)

思路：Set结构成员的值是唯一的，Set函数可以接受一个数组作为参数，用来初始化

function unique(arr) {
    // return Array.from(new Set(arr))
    return [...new Set(arr)]
}
/* 这里如果直接返回new Set(arr)的话，结果会是这样： Set(7) {1, 2, 3, 4, 5, …} */
let arr = [1,2,3,4,1,2,3,5,6,7]
console.log(unique(arr));