判断一个数组中是否有相同的元素
/*
* 判断数组中是否有相同的元素的代码 */
// 方案一
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删除数组重复元素的操作
1. 方案一遍历数组使用indexOf方法，代码如下：
/*
* 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]
2. 方案二：数组下标判断法；
/*
* 数组下标判断法
* 思路：先定义一个新数组，循环当前数组，使用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]
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]
4. 方案四：对象键值对法
/*
* 对象键值法(该方法性能最优)
* @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]
Javascript删除数组里面的某个元素
方案一：使用indexOf和splice()方法删除某个元素；
/*
* 为了支持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]}
推荐公众号：前端达人
专注分享当下最实用的的前端技术！
长按二维码点选（识别图中二维码）
长按二维码点选（识别图中二维码）
扫一扫
768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
