Javascript 二维数组去重

[[a,1],[b,2],[a,2]] 去除[a,2]

输入一串url 和一个待去除参数,输出筛选后的结果,第二个参数缺省的话,去除重复部分。

1
2
stripUrlParams('www.codewars.com?a=1&b=2&a=2', ['b'])
// returns 'www.codewars.com?a=1'

思路是先将querry参数变成二维数组再去重,对象的键值是唯一的,将参数转化为数组后,遍历数组,若在对象中已经存在参数名称则跳过;否则添加参数与值;然后遍历对象组合URL。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
function stripUrlParams(url, arr) {
var domain = url.substr(0, url.lastIndexOf('?')+1);
if(url.lastIndexOf('?') == -1)
domian = url;
var query = url.substr(url.lastIndexOf('?')+1);
var obj = {};
var argsArr = query.split('&');
for(var i in argsArr) {
var tmp = argsArr[i].split('=');
if(obj[tmp[0]] == null)
obj[tmp[0]]=tmp[1];
}
query = "";
for(var i in obj) {
// 去掉arr中的参数
var is = true;
if(arr != null)
for(var j in arr) {
if(i == j)
is = false;
}
if(is) {
query += i + "=" + obj[i]+"&";
}
}
return domain + query.substr(0, query.length-1);
}
var url = stripUrlParams('www.codewars.com?a=1&b=2&a=2', ['b'])
console.log(url);

仅仅对于去重问题,可以简单的用一个reduce解决:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var arr = [['a', 1], ['b', 2], ['a', 2]];
var result = arr.reduce((function () {
var map = {};
return function (result, next) {
var key = next[0];
if (!map[key]) {
map[key] = true;
result.push(next);
}
return result;
};
})(), []);
console.log(JSON.stringify(result));

第二种方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function stripUrlParams(url, varible) {
var urlArr = url.split('?')[1].split('&').map(function(item) {
return item.split('=');
})
var hash = {};
var result = [];
for (var i = 0; i < urlArr.length; i++) {
hash[urlArr[i][0]] ? '' : (hash[urlArr[i][0]] = true, urlArr[i][0] !== varible && result.push(urlArr[i]));
}
return url.split('?')[0] + '?' + result.reduce(function(prev, next) {
return prev + next.join('=');
}, '')
}
console.log(stripUrlParams('www.codewars.com?a=1&b=2&a=2&d=8', 'b'));
//www.codewars.com?a=1d=8

第三种:
思路:
将二维数组转换成一位数组去比较,将二级元素转换为字符串比较方便,但是为了区分类型,引入typeof拼接,之后对这个一维数组查重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function fun(input) {
var input = input || [];
var temp = input.map(function (item) {
return item.map(function (_item) {
return _item + ' ' + typeof _item;
}).join('|');
});
// temp : ['a string|1 number', 'b string|2 number', 'a string|2 number']
var indexArr = [];
temp.map(function (item, index, arr) {
for (var i = 0; i < index; i++) {
if (arr[i] !== item) indexArr.push(index);
}
});
var result = [];
for (var i = 0; i < indexArr.length; i++) {
result.push(input[i]);
}
return result;
}
console.log(fun(input));

单层循环来搞定。这个特殊问题,可以转化到单层数组去重问题上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var tidy = function(arr) {
var i = 0,
j = arr.length,
cache = {},
key, result = [];
for (; i < j; i++) {
key = arr[i][0];
key = typeof(key) + key;
if (!cache[key]) {
cache[key] = 1;
result.push(arr[i]);
}
}
return result;
};

测试

1
2
var arr = [['a', 1], ['b', 2], ['a', 2]];
tidy(arr);

第四种:

1
2
3
4
5
6
7
8
9
var url = 'www.codewars.com?a=1&b=2&a=2';
var usArr = url.split('?')[1];
var usMap = {};
usArr.split('&').forEach(function(a,b){
var s = a.split('=');
!usMap[s[0]] && (usMap[s[0]] = s[1]);
})
console.log(usMap)

,