原生js数组去重常用方法小结

数组去重

工作中在处理筛选数据的时候常常会有些数据重复，在处理这些数据同时简单总结四种常用的去重复方法

• sort 排序法：去重后内容有序，待去重的内容中不可以包含是字符串
• 双循环法：去重后内容有序，待去重的内容中可以包含是字符串
• indexOf/includes：去重后内容无序，待去重的内容中可以包字符串
• es6 的new Set：去重后内容无序，待去重的内容中可以包字符串

---

1、排序法

let ary1 = [11, 3, 5, 2, 5, 42, 2, 3, 2, 1, 5];
function sortAry(ary) {
let newArray = [];
    ary.sort(function (a, b) {
        return a - b;
    });
    for (let i = 0; i < ary.length; i++) {
        // 方案一
        /*if (ary[i] != ary[i+1]) {
            newArray.push(ary[i])
        }*/
        // 方案二
        if (ary[i] == ary[i+1]){
            ary.splice(i,1);
            i--;  // splice删除数组中的某一项，会形成数组塌陷，导致比较的时候会跳过当前项，i--作用是为了防止数组塌陷，即让循环体再按照原来的值循环一次
            }
        }
        // return newArray;  // 方案一返回新数组
        return ary;  // 方案二返回原数组
}
console.log(sortAry(ary1));

2、双循环法

let ary2 = [11, 3, 5, 2, 5, 42, 2, 3, 2, 1, 5];
function doublebfor(ary) {
    let obj = {}, newAry = [];
    for (let key in ary) {
        let cur = ary[key];
        // 把数组中的每一项当做属性名有当做属性值，存储到对象中
        // 但是因为对象中的属性名是独一无二的，所以对象中只会保存到不重复的键值对（每一组键值对）
        obj[cur] = cur;
    }
    for (let key in obj) {
   	    // 又因为属性名都是属于字符串，不能给新数组单独添加key，因为全部都是字符串，需要把对象的属性值添加到新的数组当中
        newAry.push(obj[key]);
    }
    return newAry
}
console.log(doublebfor(ary2));

3、indexOf / includes

let ary3 = [11, 3, 5, 2, 5, 42, 2, 3, 2, 1, 5];
function indexAry(ary) {
    let newAry = [];
    for (let i = 0; i < ary.length; i++) {
        /* 方案一 */
        // indexOf 判断新数组中是否存在这一项，存在返回存在的返回对应的索引，不存在返回-1
        /*if (newAry.indexOf(ary[i]) == -1) {
             newAry.push(ary[i]);
         }*/
         /* 方案二 */
         // includes 判断新数组中是否存在这一项，存在true，不存在false
         if (!newAry.includes(ary[i])){
             newAry.push(ary[i]);
         }
    }
    return newAry;
}
console.log(indexAry(ary3));

4、es6 newSet 这个方法利用Set 这个数据类型中，存储的值都是独一无二的特性进行实现

let ary4 = [11, 3, 5, 2, 5, 42, 2, 3, 2, 1, 5];
console.log([...new Set(ary4)]);  

以上四种去重的输出结果：