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