Js数组常见的题目，你能做对几个

/*
 * 判断数组中是否有相同的元素的代码 */
// 方案一
function isRepeat1(arrs) {
    if (arrs.length > 0) {
        var s = arrs.join(",");
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (s.replace(arrs[i], "").indexOf(arrs[i]) > -1) {
                return true;
            }
        }
    }
    return false;
}
// 方案二
function isRepeat2(arrs) {
    var hash = {};
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (hash[arrs[i]]) {
                return true;
            }
            hash[arrs[i]] = true;
        }
    }
    return false;
}
var arrs = [1, 4, 3, 2, 5];
console.log(isRepeat1(arrs)); // false
var arrs2 = [1, 2, 3, 1];
console.log(isRepeat1(arrs2)); // true  
var arrs = [1, 4, 3, 2, 5];
console.log(isRepeat2(arrs)); // false
var arrs2 = [1, 2, 3, 1];
console.log(isRepeat2(arrs2)); // true

/*
 * 计算数组中每个元素在数组中出现的个数
 * @param {arrs} 数组
 * @method 定义一个新数组，循环当前的数组，使用一个临时的变量temp保存当前的值，外层for循环定义一次变量count=0，当做计数器，内部再一次循环数组判断当前的数组与外层的数组某一项是否相等，如是count++; 然后把当前的一项值置为-1，下一次就不会再继续循环了
 * @return {newArrs} 返回一个新数组 */
function arrayElemCount(arrs) {
    var newArrs = [];
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            var temp = arrs[i];
            var count = 0;
            for (var j = 0, jlen = arrs.length; j < jlen; j += 1) {
                if (arrs[j] == temp) {
                    count++;
                    arrs[j] = -1;
                }
            }
            newArrs.push(temp + ":" + count);
        }
    }
    return newArrs;
}
var arrs = [1, 2, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3];
console.log(arrayElemCount(arrs));
// 打印如下：["1:3", "2:3", "-1:6", "-1:6", "3:2", "4:1", "5:1", "6:1", "7:1", "-1:12", "-1:12", "-1:12"]// 键值为-1的，都可以去掉

/*
 * javascript数组去重方案一
 * @param {arrs} 原数组
 * @method 新建一个新数组，遍历原数组，在新数组内使用indexOf查找原数组内的每一项，如果没有找到，就把当前的项存入新数组里面去，这样就过滤掉
 * 重复项 indexOf方法在IE8及IE8以下不支持，因此有必要封装一个
 * @return {newArrays} 返回新数组 */
function arrayUnique(arrs) {
    var newArrays = [];
    for (var i = 0, ilen = arrs.length; i < ilen; i++) {
        if (newArrays.indexOf) {
            if (newArrays.indexOf(arrs[i]) == -1) {
                newArrays.push(arrs[i]);
            }
        } else {
            if (indexOf(arrs[i], newArrays) == -1) {
                newArrays.push(arrs[i]);
            }
        }
    }
    return newArrays;
}
/*
 * 为了支持IE8及以下浏览器需要封装一个indexOf方法
 * @param {arr,arrs} 某一项 原数组
 * @return 返回数组某一项 */
function indexOf(arr, arrs) {
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs[i] == arr) {
                return i;
            }
        }
    }
    return -1;
}
var arrs = [1, 2, 3, 1, 2, 3];
console.log(arrayUnique(arrs)); // [1,2,3]

/*
 * 数组下标判断法
 * 思路：先定义一个新数组，循环当前数组，使用indexOf方法，如果在当前的数组的第i项在当前数组中的位置是i项的话，说明该项在数组中并未出现过，存入新数组，否则的话，在原数组中出现过，因此需要过滤掉。性能和第一种方案差不多。
 * @return {newArrars} 返回新数组 */
function arrayUnique(arrs) {
    var newArrays = [];
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs.indexOf) {
                if (arrs.indexOf(arrs[i]) == i) {
                    newArrays.push(arrs[i]);
                }
            } else {
                if (indexOf(arrs[i], arrs) == i) {
                    newArrays.push(arrs[i]);
                }
            }
        }
    }
    return newArrays;
}
/*
 * 为了支持IE8及以下浏览器需要封装一个indexOf方法
 * @param {arr,arrs} 某一项 原数组
 * @return 返回数组某一项 */
function indexOf(arr, arrs) {
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs[i] == arr) {
                return i;
            }
        }
    }
    return -1;
}
var arrs = [1, 2, 1, 3, 1];
console.log(arrayUnique(arrs)); // [1,2,3]

/*
 * 排序后相邻去除法
 * @method 新建一个新数组，遍历当前的数组，如果当前的数组某一项不等于新数组的最后一项的话，就把当前的项存入新数组中，最后返回新数组 */
function arrayUnique(arrs) {
    var newArrays = [];
    if (arrs.length > 0) {
        arrs.sort();
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs[i] !== newArrays[newArrays.length - 1]) {
                newArrays.push(arrs[i]);
            }
        }
    }
    return newArrays;
}
var arrs = [1, 2, 1, 3, 1];
console.log(arrayUnique(arrs)); // [1,2,3]

/*
 * 对象键值法(该方法性能最优)
 * @method 定义一个空对象和空新数组，遍历当前的数组，判断该对象是否存在数组的某一项，如果不存在
 * 就当当前的某一项存入新数组去，且当前的项置为-1 目的过滤掉重复的项 */
function arrayUnique(arrs) {
    var newArrays = [];
    var hash = {};
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (!hash[arrs[i]]) {
                hash[arrs[i]] = 1;
                newArrays.push(arrs[i]);
            }
        }
    }
    return newArrays;
}
var arrs = [4, 5, 2, 1, 2, 1, 3, 1];
console.log(arrayUnique(arrs)); // [4,5,2,1,3]

/*
 * 为了支持IE8及以下浏览器需要封装一个indexOf方法
 * @param {arr,arrs} 某一项 原数组
 * @return 返回数组某一项 */
function indexOf(arr, arrs) {
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs[i] == arr) {
                return i;
            }
        }
    }
    return -1;
}
/*
 * 删除数组里面的某个元素
 * @param {elem,arrs} 要删除的元素 原数组
 * 思路：先使用indexOf方法在数组里面找到该元素的位置，然后使用splice()方法删除一个元素
 * @return {elem,arrs} 返回一个对象，对象有2个元素，第一个是被删除的元素elem键，另一个是被删除元素
 后的数组，也就是新数组 [2,3]  */
function removeAttrsElem(elem, arrs) {
    var newElem;
    if (arrs.length > 0) {
        var index = indexOf(elem, arrs);
        if (index > -1) {
            newElem = arrs.splice(index, 1);
        }
    }
    return {
        elem: newElem,
        arrs: arrs
    }
}
var arrs = [1, 2, 3];
var elem = 1;
console.log(removeAttrsElem(elem, arrs));
// 返回一个对象 {elem:1,arrs:[2,3]}

/*
  * 删除数组里面的某个元素
  * @param {elem,arrs} 要删除的元素 原数组
  * 思路：直接遍历数组 取其中某一项 如果某一项与该元素相同的话，直接截取，和第一种方案类似，比第一种方案简单
  * @return {elem,arrs} 返回一个对象，对象有2个元素，第一个是被删除的元素elem键，另一个是被删除元素
  后的数组，也就是新数组 [2,3]  */
function removeAttrsElem(elem, arrs) {
    var newElem;
    if (arrs.length > 0) {
        for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {
            if (arrs[i] == elem) {
                newElem = arrs.splice(i, 1);
            }
        }
    }
    return {
        elem: newElem,
        arrs: arrs
    }
}
var arrs = [1, 2, 3];
var elem = 1;
console.log(removeAttrsElem(elem, arrs));
// 返回一个对象 {elem:1,arrs:[2,3]}