Javascript 二维数组去重

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

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

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

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

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解决：

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));

第二种方法：

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拼接，之后对这个一维数组查重

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));

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

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;
};

测试

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

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)