深拷贝的实现方案

• method-1-递归

function copy(obj) {
    var newObj = {};
    for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            var value = obj[i];
            if (typeof value === "number" ||
                typeof value === "boolean" ||
                typeof value === "string" ||
                value === undefined ||
                value === null) {
                newObj[i] = value;
            } else {
                newObj[i] = copy(value);
            }
        }
    }
    return newObj;
}

• method-2-JSON

function copy(obj) {
    var newObj = JSON.parse(JSON.stringify(obj)); 
    //stringify将JS对象转换成JSON字符串；parse将JSON字符串转换成JS对象。
    return newObj;
}

数组去重

• method-1--->实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中。

var arr = [1, 1, 1, 2, 2, 5, 6, 9, 8, 10, 10, 5, 15]
    //仅适用于一维数组
function unique1(array) {
    var n = [];
    for (var i = 0; i < array.length; i++) {
        if (n.indexOf(array[i]) == -1) {
            n.push(array[i]);
        }
    }
    return n;
}

unique1(arr);

• method-2--->实现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，不是的话给对象新增该键并放入新数组。注意 点： 判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为一样；例如： a[1]、a["1"] 。解决上述问题还是得调用“indexOf”。

var arr = [1, 1, 5, 9, 6, [1, 2], 3, 8, [1, 2], 11, 11, 55, 55, 5, 6, 3, 8, [1, 2]]
    //能处理二维数组，但是不能实现二维数组里面的去重
function unique2(array) {
    var n = {},
        r = [],
        len = array.length,
        val, type;
    for (var i = 0; i < array.length; i++) {
        val = array[i];
        type = typeof val;
        if (!n[val]) {
            n[val] = [type];
            r.push(val);
        } else if (n[val].indexOf(type) < 0) {
            n[val].push(type);
            r.push(val);
        }
    }
    return r;
}
unique2(arr);

• method-3--->实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组。

var arr = [1, 1, 5, 9, 6, 3, 8, 11, 11, 55, 55, 5, 6, 3, 8]
    //仅适用于一维数组
function unique3(array) {
    var n = [array[0]];
    for (var i = 1; i < array.length; i++) {
        //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
        //那么表示第i项是重复的，忽略掉。否则存入结果数组
        if (array.indexOf(array[i]) == i) {
            n.push(array[i]);
        }
    }
    return n;
}
unique3(arr);

• method-4--->实现思路：给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。

var arr = [1, 1, 5, 9, 6, 3, 8, 11, 11, 55, 55, 5, 6, 3, 8]
    //仅适用于一维数组
function unique4(array) {
    array.sort();
    var re = [array[0]];
    for (var i = 1; i < array.length; i++) {
        // 将相同的值相邻，然后遍历去除重复值
        if (array[i] !== re[re.length - 1]) {
            re.push(array[i]);
        }
    }
    return re;
}
unique4(arr);

• method-5--->实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）

var arr = [1, 1, 5, 9, 6, 3, 8, 11, 11, 55, 55, 5, 6, 3, 8]
    //仅适用于一维数组
function unique5(array) {
    var r = [];
    for (var i = 0, l = array.length; i < l; i++) {
        for (var j = i + 1; j < l; j++)
        // 思路：获取没重复的最右一值放入新数组
            if (array[i] === array[j]) {
            j = ++i;
            r.push(array[i]);
        }
    }
    return r;
}
unique5(arr);