数组去重

数组去重的几种方法，自己瞎总结一下子，其实好多都是相同的思路，随便记录一下

    var a = [1, 3, 3, 9, 1, 4];

第一种 思路：新建一个空数组b，然后循环a， 内部嵌套b的循环，比较b内，是否有a[i]这个值，没有的话，就将a[i]推入b;有就不推

            var b = [];
            for (var i = 0; i < a.length; i++) {
                var flag = true;
                for (var j = 0; j < b.length; j++) {
                    if (b[j] == a[i]) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    b.push(a[i]);
                }
            }

第二种 思路：第一种思路的优化版本，不用设置一个开关变量flag，判断b能正常循环到最后一位，就说明b内没有a[i]

            var b = [];
            for (var i = 0; i < a.length; i++) {
                for (var j = 0; j <b.length; j++) {
                    if (b[j] == a[i]) {
                        break;
                    }
                }
                if (j== b.length) {
                    b.push(a[i]);
                }  
            }

第三种 思路：和第一种思路同理，只不过变换了一下跳出循环的方式，从break变成了return

            var b = [];

            for (var i = 0; i < a.length; i++) {
                function abc() {
                    for (var j = 0; j < b.length; j++) {
                        if (b[j] == a[i]) {
                            return false;
                        }
                    }
                    return true;
                }
                if (abc()) {
                    b.push(a[i]);
                }
            }

第四种 思路：拿a数组的每一项，和这一项后面的数据比较，如果相同的话，就不push进b数组

            var b = [];
            for (var i=0;i<a.length;i++){
                var flag = true;
                for(var j = i+1;j<a.length;j++){
                    if(a[i]==a[j]){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    b.push(a[i]);
                }
            }

第五种 思路： 第四种方法的优化，当a中第i项与后面数据有相同情况，就跳过第i项，然后去i+1项；j取值++i后马上又执行for循环里的j++操作

            var b = [];
            for (var i=0;i<a.length;i++){
                for(var j = i+1;j<a.length;j++){
                    if(a[i]==a[j]){
                        j = ++i;
                    }
                }
                b.push(a[i]);
            }

第六种 思路：拿a里的每一个数据和后面所有项比较，有相同的，就删除当前项，不用再重新声明一个空数组

            for (var i=0;i<a.length;i++){
                for(var j = i+1;j<a.length;j++){
                    if(a[i]==a[j]){
                        a.splice(i,1);
                        --i;
                        j = i+1;
                    }
                }
            }

第七种 思路：和第六种相同，但是如果检查到相同项，第六种是删除前面的，这种是删除后面的

            for (var i=0;i<a.length;i++){ 
                for(var j = i+1;j<a.length;j++){
                    if(a[i]==a[j]){
                        a.splice(j,1);
                        --j;
                    }
                }
            }

第八种 思路：利用对象不能有相同属性名的前提，去筛选出相同项，只用循环一次，前面都是循环两次

            var obj = new Object();
            var b = [];
            for(var i=0;i<a.length;i++){
                if(!obj[a[i]]){
                    obj[a[i]] = true;
                    b.push(a[i]);
                }
            }

第九种 思路：第八种的拓展思路，不用再声明一个b数组，检测到相同项，自动删除，然后记得i–，要么会有遗漏项

            var obj = new Object();
            for(var i=0;i<a.length;i++){
                if(!obj[a[i]]){
                    obj[a[i]] = true;
                }else{
                    a.splice(i,1);
                    i--;
                }
            }

第十种 思路：ES6的新函数，Set传入数组，默认不能有相同项

            var set = new Set(a); 
            var b = Array.from(set);
            //可简化为： 
            var b= Array.from(new Set(a));

第十一种 思路:

未完待续。。。