js数组去重

1. indexof

const arr = [1, 2, 3, 4, 8, 4, 1, 2]

const arr_dul = []
for (let i = 0; i < arr.length; i++) {
    if (arr_dul.indexOf(arr[i]) === -1) {
        arr_dul.push(arr[i])
    }
}
console.log(arr_dul)

2. includes

const arr = [1, 2, 3, 4, 8, 4, 1, 2]

const arr_dul = []
for (let i = 0; i < arr.length; i++) {
    // if (arr_dul.indexOf(arr[i]) === -1) {
    //     arr_dul.push(arr[i])
    // }
    if (!arr_dul.includes(arr[i])) {
        arr_dul.push(arr[i])
    }
}
console.log(arr_dul)

3. ES6的 Set

const arr = [1, 2, 3, 4, 8, 4, 1, 2]

// const arr_dul = []
// for (let i = 0; i < arr.length; i++) {
//     // if (arr_dul.indexOf(arr[i]) === -1) {
//     //     arr_dul.push(arr[i])
//     // }
//     if (!arr_dul.includes(arr[i])) {
//         arr_dul.push(arr[i])
//     }
// }
arr_dul = [...new Set(arr)]
console.log(arr_dul)

4. 深度去重

// 定义判断类型的函数
function type(ele) {
    return Object.prototype.toString.call(ele).slice(8, -1)
}

// console.log(type(arr))
// 根据类型来进行去重，回调循环， 针对对象类型
function objectUnique(eleA, eleB) {
    if (type(eleA) !== 'Object' && type(eleB) !== 'Object') {
        // console.log('不是对象，可以直接对比')
        return false
    }
    // 下面就使用Object.keys()方法将eleA的属性扒出来，循环两者相对比
    const keys = Object.keys(eleA)
    keys.forEach(ele => {
        // console.log(ele)
        // 再做判断，判断两者的相同的属性是否都是对像或者数组，是对象的话继续调用objUnique, 是数组的话调用数组的对比
        if (type(eleA[ele]) === 'Object' && type(eleB[ele]) === 'Object') {
            objectUnique(eleA[ele], eleB[ele])
        }
        else if (type(eleA[ele]) === 'Array' && type(eleB[ele]) === 'Array') {
            arrayUnique(eleA[ele], eleB[ele])
        }
        else if (eleA[ele] !== eleB[ele]){
            return false
        }
    })
    return true
}
// 针对数组类型
function arrayUnique(arrayA, arrayB) {
    if (type(arrayA) !== 'Array' && type(arrayB)!=='Array') {
        return false
    }
    if (arrayA.length != arrayB.length) {
        return false
    }
    for(let i = 0; i < arrayA.length; i++) {
        if (type(arrayA[i]) === 'Object' && type(arrayB[i]) === 'Object') {
            objectUnique(arrayA[i], arrayB[i])
        }
        else if (type(arrayA[i]) === 'Array' && type(arrayB[i]) === 'Array') {
            arrayUnique(arrayA[i], arrayB[i])
        }
        else if (arrayA[i] !== arrayB[i]){
            return false
        }    
    }
    return true
}
const arr = [
    {a: 1}, [{a: 1}, {b: 2}], 3, {a: 1}, 1, 1, [{a: 1}, {b: 2}], [[{}]], [[{}]]
]
function unique(arr) {
    // 先将数组的最上面的一级进行区分，使用普通类型，数组类型，对象类型三个数组区分
    const arr_common = []
    const arr_array = []
    const arr_object = []
    arr.forEach(element => {
        if (type(element) === 'Array') {
            arr_array.push(element)    
        } else if (type(element) === 'Object') {
            arr_object.push(element)
        } else {
            arr_common.push(element)
        }
    });
    // 对象
    for(let i = 0; i < arr_object.length; i++) {
        for (let j = i + 1; j < arr_object.length; j++) {
            if (objectUnique(arr_object[i], arr_object[j])) {
                arr_object.splice(j, 1)
                j--
            }
        }
    }
    // 数组
    for(let i = 0; i < arr_array.length; i++) {
        for (let j = i + 1; j < arr_array.length; j++) {
            if (arrayUnique(arr_array[i], arr_array[j])) {
                arr_array.splice(j, 1)
                j--
            }
        }
    }
    // 普通对象
    const commonList = [...new Set(arr_common)]

    const arr_final = [...commonList, ...arr_object, ...arr_array]
    console.log(arr_final)
}

unique(arr)

至于其他的，网上很多