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)