JS数组去重

数组去重 无非基于以下几种特性

1.  双重循环（sort()排序，splice）     【都是利用循环遍历实现】
2.  includes方法 或  indexOf方法 【利用包含和不包含条件】
3.  obj特性，set，map 都是obj的变种

准备数据

let arr = [1, 2, 3, 4, 5, 6, 1, 2, 3, 45, 6, 4, 3, 2, 1]

1. 利用 includes()【包含某个元素】 或  indexOf()【不等于-1就是 包含某个元素】或 hasOwnProperty【方法用来判断某个对象是否含有指定的自身属性】

• includes分字符串方法，数组方法
• includes字符串：includes() 方法用于判断字符串是否包含指定的子字符串。返回值：true/false
• includes数组：Array includes() 方法检查数组是否在其条目中具有特定值，参数一：要搜索的项，参数二：搜索的下标，返回值:true/false
• indexOf分字符串方法，数组方法
• indexOf字符串：字符串是否包含某传入的相同字符，不包含返回-1,包含则返回其下标（只返回包含的第一个下标）
• indexOf数组：数组元素，是否包含某传入的相同字符，不包含返回-1,包含则返回其下标（只返回包含的第一个下标）
• hasOwnProperty方法用来判断某个对象是否含有指定的自身属性【不会查找到原型链，也就是说数组里面是引用类型无法判断】

function f1(arr) {
    let newArr = []
    arr.forEach(v => {
        // newArr.includes(v) ? true : newArr.push(v)
        // pre.hasOwnProperty(cur) ? true : pre.push(cur)
        newArr.indexOf(v) != -1 ? true : newArr.push(v)
    })
    return newArr
}

2.利用 filter过滤，和indexOf特性【找到元素就返回元素当前索引，找不到就-1】 

function f2(arr) {
    return arr.filter((v, i) => {
        return arr.indexOf(v) === i
    })
}

3. reduce的扩展写法

function f3(arr) {
    return arr.reduce((pre, cur) => {
        pre.includes(cur) ? true : pre.push(cur)
        return pre
    }, [])
}

 4. 利用obj特性【key是唯一】

function f4(arr) {
    let newArr = []
    let obj = {}
    arr.forEach(v => {
        if (!obj[v]) {
            obj[v] = true
            newArr.push(v)
        }
    })
    return newArr
}

 5. 利用 set的特性来实现【set元素不重复】

function f5(arr) {
    // return [...new Set(arr)]
    return Array.from(new Set(arr))
}

 6. 双重for循环，数组去重【利用newArr里面的每一项对象外层循环的每一项】

function f6(arr) {
    let newArr = []
    for (let i = 0; i < arr.length; i++) {
        let flag = true
        for (let j = 0; j < newArr.length; j++) {
            if (arr[i] === newArr[j]) {
                flag = false
                break
            }
        }
        if (flag) {
            newArr.push(arr[i])
        }
    }
    return newArr
}

7. sort排序，在第一对比第二个

function f7(arr) {
    let arrAll = arr.sort((a, b) => a - b)
    let newArr = []
    for (let i = 0; i < arrAll.length; i++) {
        if (arrAll[i] !== arrAll[i + 1]) {
            newArr.push(arrAll[i])
        }
    }
    return newArr
}

 8. map，利用map特性

function f10(arr) {
    let map = new Map();
    arr.forEach(v=>{
        // map 相同的key 会更新值（保证key相同就行）
        map.set(v,true)
    })
    return [...map.keys()]
}

 9.双重for循环+splice(剪切数组)

function f9(arr) {
    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)
                j--
            }
        }
    }
    return arr
}