码迷,mamicode.com
首页 > 编程语言 > 详细

js 数组去重方法总结

时间:2019-12-13 14:19:58      阅读:96      评论:0      收藏:0      [点我收藏+]

标签:没有   演示   object   特点   foreach   中继   方法   数据   from   

var arr = [1, 1, ‘true‘, ‘true‘, true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, ‘NaN‘, ‘NaN‘, 0, 0, ‘a‘, ‘a‘, {}, {}];

/*
 * ES3 的方法
 */

// 方法一 思路:新建空数组,利用双层for循环,逐一取出传入数组的项与新数组中的每一项做对比,如果没有相同的则将该项插入新数组中,如果对比项相同则跳出当前循环回到父循环中继续做下一轮对比。新数组为去重后的数组,不会影响老数组
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique1(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (newArr.length == 0) {
            newArr.push(arr[i]);
        } else {
            var isPush = true;
            for (var k = 0; k < newArr.length; k++) {
                if (newArr[k] == arr[i]) {
                    isPush = false;
                    break;
                };
            };
            if (isPush == true) {
                newArr.push(arr[i]);
            }
        }
    };
    return newArr;
};
console.log(unique1(arr)); // [1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}]


// 方法二 思路:新建空数组,利用双层for循环,将传入数组的项(从第一项开始)与其后面的项做对比,如果有相同的,不做处理,如果没有相同的,就插入到新数组中。新数组为去重后的数组,不会影响老数组
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique2(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        for (var k = i + 1; k < arr.length; k++) {
            if(arr[k] == arr[i]){
                k = ++i;
            };
        };
        newArr.push(arr[i]);
    };
    return newArr;
};
console.log(unique2(arr)); // ["true", true, 15, null, NaN, NaN, "NaN", 0, "a", {…}, {…}]


// 方法三 思路:双层for循环,让当前项与其后面的项做比较,如果相同,就对后面重复的项做删除操作,会影响老数组。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
// 备注 示例方法是正向遍历,也可以逆向遍历,此处不做演示
function unique3(arr) {
    for (var i = 0; i < arr.length; i++) {
        for (var k = i + 1; k < arr.length; k++) {
            if (arr[k] == arr[i]) {
                arr.splice(k, 1);
                k--;
            }
        }
    }
};
unique3(arr)
console.log(arr); // [1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}]


// 方法四 思路:利用对象的属性名字不能重复的特点,建立新对象,将数组中的某项作为属性名放到对象当中,使用for循环判断对象属性是否存在,如果存在,不进行操作,如果不存在则放置到对象中。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN、Object。
// 缺点:针对 NaN和‘NaN‘, 对象的key会视为一个key,区分不了NaN和‘NaN‘。
function unique4(arr) {
    var newObj = {},
        newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (!newObj[arr[i]]) {
            newObj[arr[i]] = true;
            newArr.push(arr[i]);
        }
    }
    return newArr;
};
console.log(unique4(arr)); // [1, "true", 15, false, undefined, null, NaN, 0, "a", {…}]


// 方法五 思路:利用sort()方法先将数组排序,然后使用for循环遍历排序后的数组,如果当前项与其后面相邻的项不相同,则将该项插入新数组中,此方法不改变元素组,返回排序后的新数组。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique5(arr){
    var sortArr = arr.sort(function(a, b){
        return a - b;
    });
    var newArr = [sortArr[0]];
    for(var i = 1; i< sortArr.length;i++){
        if(sortArr[i] !== sortArr[i-1]){
            newArr.push(sortArr[i]);
        }
    };
    return newArr;
};
console.log(unique5(arr)); // [1, "true", false, null, 0, true, 15, {…}, {…}, NaN, NaN, "NaN", "a", undefined]


// 方法六 思路:利用sort()方法先将数组排序,然后创建递归函数判断当前项与其后面的项是否相同,相同用splice方法删除,然后运行递归函数继续进行判断操作。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique6(arr) {
    var newArr = arr,
        arrLen = arr.length;
    var sortArr = arr.sort(function(a, b) {
        return a - b;
    });

    function loop(index) {
        if (index >= 1) {
            if (newArr[index] === newArr[index - 1]) {
                newArr.splice(index, 1);
            };
            loop(index - 1);
        }
    };
    loop(arrLen - 1);
    return newArr;
};
console.log(unique6(arr)); // [1, "true", false, null, 0, true, 15, {…}, {…}, NaN, NaN, "NaN", "a", undefined]



/*
 * ES5的方法
 */

// 方法七 思路:结合indexOf()方法和forEach()方法,如果老数组中循环的项在新数组中不存在,则将该项插入新数组,不改变老数组,返回新数组。注意indexOf()方法也可以用lastIndexOf()方法替代,forEach()方法也可以用for循环替代的。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique7(arr){
    var newArr = [];
    // for(var i = 0; i< arr.length; i++){
    //     if(newArr.indexOf(arr[i]) === -1){
    //         newArr.push(arr[i]);
    //     }
    // }
    arr.forEach(function(item, index, array){
        if(newArr.indexOf(item) === -1){
            newArr.push(item);
        }
    });
    return newArr;
};
console.log(unique7(arr)); // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {…}, {…}]


// 方法八 思路:结合includes()方法和forEach()方法,includes方法检测数组中是否有某个值。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN。
// 缺点:不能过滤掉Object
function unique8(arr){
    var newArr = [];
    arr.forEach(function(item, index, array){
        if(!newArr.includes(item)){
            newArr.push(item);
        }
    });
    return newArr;
};
console.log(unique8(arr)); // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]


// 方法九 思路:结合includes()方法和filter()方法,includes方法检测数组中是否有某个值。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN。
// 缺点:不能过滤掉Object
function unique9(arr){
    var newArr = [];
    arr.filter(function(item){
        if(!newArr.includes(item)){
            newArr.push(item);
        }
    });
    return newArr;
};
console.log(unique9(arr)); // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]


// 方法十 思路:结合indexOf()方法和filter()方法,includes方法检测数组中是否有某个值。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null。
// 缺点:不能过滤掉 NaN、Object
function unique10(arr){
    var newArr = [];
    arr.filter(function(item){
        if(newArr.indexOf(item) === -1){
            newArr.push(item);
        }
    });
    return newArr;
};
console.log(unique10(arr));  // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {…}, {…}]


// 方法十一 思路:利用map()方法去重。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN。
// 缺点:不能过滤掉 Object
function unique11(arr){
    var map = new Map();
    var newArr = [];
    arr.forEach(function(item){
        if(map.has(item)){
            map.set(item, true);
        } else {
            map.set(item, false);
            newArr.push(item);
        }
    });
    return newArr;
};
console.log(unique11(arr));  // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]


// // 方法十二 思路:利用hasOwnProperty去重。
// // 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN、Object。
function unique12(arr){
    var obj = {};
    return arr.filter(function(item){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
    });
};
console.log(unique12(arr));  // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}]


/*
 * ES6的方法
 */

// 方法十三 思路:利用ES6中的拓展运算符...和set()方法。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN。
// 缺点:不能过滤掉Object
function unique13(arr){
    return [...new Set(arr)];
};
console.log(unique13(arr)); // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]


// 方法十四 思路:利用ES6中Array.from()方法和set()方法,set()方法可以生产set数据结构,这种结构成员的值是唯一的,然后用Array.from()方法将set对象转为数组。
// 优点:该方法可以顾虑到重复的 String、Boolean、 Number、undefined、null、NaN。
// 缺点:不能过滤掉Object
function unique14(arr){
    return Array.from(new Set(arr));
};
console.log(unique14(arr)); // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]

js 数组去重方法总结

标签:没有   演示   object   特点   foreach   中继   方法   数据   from   

原文地址:https://www.cnblogs.com/jiangtengteng/p/12034472.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!