获取 url 参数

function getUrlParam(sUrl, sKey) {
    var paramsN = sUrl.split("?")[1];//取出url后的字符串
    var params = paramsN.split("#")[0];//剔除字符串#后的杂质
    var param = params.split("&");//将字符串分割为键值对为一项的数组
    var arr = [];

    if(sKey){//如果有参数
        for(var i = 0;i<param.length;i++){//遍历键值对数组
            var keyV = param[i].split("=");//分开键和值
            if(keyV[0] === sKey){//如果有和传入的参数一样的键，则将其值插入到空数组中
                arr.push(keyV[1]);
            }
        }
        if(arr.length === 0){//如果数组仍为空，则证明没有传入的参数的值
            return "";
        }else if(arr.length > 1){//有多个值
            return arr;
        }else{//只有一个值
            return arr[0];
        }
    }else{//没有传入参数，返回对象
        var obj = {};
        for(var i = 0;i<param.length;i++){//遍历
            var keyV = param[i].split("=");//分开键和值
            if(obj[keyV[0]]){//如果对象中有该属性
                obj[keyV[0]].push(keyV[1])//插入该属性中的数组中
            }else{
                obj[keyV[0]] = [keyV[1]]//如果没有则创建一个数组并且把值放入该数组中
            }
        }
        for(var key in obj){//遍历插入数据的对象
            if(obj[key].length === 1){//如果该对象的属性值的数组的长度为一
                obj[key] = obj[key][0]//则让该对象的该属性值为数组里的值
            }
        }
        return obj;
    }
}

//参考大神的方法
function getUrlParam(sUrl, sKey) {
    var result,Oparam = {};
    sUrl.replace(/[\?|&]?(\w+)=(\w+)/g,function($0,$1,$2){
        Oparam[$1] === void 0 ? Oparam[$1]=$2 : Oparam[$1]=[].concat(Oparam[$1],$2);
    });
    sKey === void 0||sKey==='' ? result=Oparam : result=Oparam[sKey]||'';
    return result;
}
//不用正则表达式的方法
function getUrlParam(sUrl, sKey) {
    var psArr = /\?/.test(sUrl) ? sUrl.split('?')[1].split('#')[0].split('&') : [];
    var result,Oparam = {};
    for(var i=0;i<psArr.length;i++){
        var pA = psArr[i].split('=');
        Oparam[pA[0]] === void 0 ? Oparam[pA[0]]=pA[1] : Oparam[pA[0]]=[].concat(Oparam[pA[0]],pA[1]);
    }
    sKey === void 0||sKey==='' ? result=Oparam : result=Oparam[sKey]||'';
    return result;
}

function getUrlParam(sUrl, sKey) {
    var resObj = {};
    var reg = /(\w+)=(\w+)/g;
    while (reg.exec(sUrl)) {
        resObj[RegExp.$1] ? resObj[RegExp.$1] = [].concat(resObj[RegExp.$1], RegExp.$2) : resObj[RegExp.$1] = RegExp.$2;
    }

    if (sKey) {
        return (resObj[sKey] ? resObj[sKey] : '');
    }
    return resObj;
}

function getUrlParam(_url, name) {
    let us=_url.split('?')[1].split('&')
    //指定参数
    if(name){
        let arr=[]
        if(us.filter(item=>item.split('=')[0]==name).length>1){
           us.map(item=>{
                let str=item.split('=')
               if(str[0]==name){
                   arr.push(str[1])
               }
           })
            return arr
        }else{
          let _name = name.replace(/(?=[\\^$*+?.():|{}])/, '\\')
          let reg = new RegExp('(?:[?&]|^)' + _name + '=([^?&#]*)', 'i')
          let match = _url.match(reg)
          return !match ? '' : match[1]
        }
    }else{
        if(us.length<=0){
            return {}
        }else{
            let obj={}
            us.map(item=>{
                let str=item.split('=')
                if(obj.hasOwnProperty(str[0])){
                    obj[str[0]].push(str[1])
                }else{
                    obj[str[0]]=[str[1]]
                }
            })
            return obj
        }
    }
}

function getUrlParam(sUrl, sKey) {
    var result = {}
    sUrl.replace(/\??(\w+)=(\w+)&?/g, function(a, k, v){
        result[k] = result[k]? [...result[k]].concat(v) : v
    })
    return sKey? result[sKey]? result[sKey] : '' : result
}

//正则表达式
function getUrlParam(sUrl, sKey) {
    var obj = {};
    var reg = /[?&](\w+)=(\w+)/g;
    while(reg.exec(sUrl))
        obj[RegExp.$1] ? obj[RegExp.$1]=[].concat(obj[RegExp.$1],RegExp.$2) : obj[RegExp.$1]=RegExp.$2; 
    return sKey ? obj[sKey]||"" : obj;
}

// By ClayIdol
function getUrlParam(sUrl, sKey) {
    
    var r = [] , s = null  , i = 0;
    var regexp = new RegExp(/[?&]([\w]*)=([^&#]*)/g);
    
    while((s = regexp.exec(sUrl)) != null){
         if(!r[s[1]])r[s[1]] = s[2];
         else if(typeof(r[s[1]]) == 'object'){
             r[s[1]].push(s[2]);
         }else{
              r[s[1]] = [r[s[1]],s[2]];
         }
    }
    if(sKey){
        //有参数，返回参数值或空
        if(r[sKey]){
            return r[sKey];
        }else{
            return '';
        }
    }else{
        return r;
    }
}

function getUrlParam(sUrl, sKey) {
    const s = sUrl.split('?')[1].split('#')[0].split('&')
    const map = {}
    s.forEach(item => {
        const [key, val] = item.split('=')
        if (map[key] === undefined) map[key] = val
        else if (typeof map[key] === 'string') map[key] = [map[key], val]
        else map[key].push(val)
    })
    if (!sKey) return map
    return map[sKey] || ''
}

function getUrlParam(sUrl, sKey) {
    //正则表达式匹配key=value
            var re = /(\w+)=(\w+)/g;
            var arr = sUrl.match(re);
            var item = {};
    //判断有没有传参数
            var key = sKey || false;
            var key1;
    //如果有相同的参数名，flag会变成true
            var flag = false;
            for (var i = 0; i < arr.length; i++) {
                //键
                var item1 = arr[i].split('=')[0];
                //值
                var value = arr[i].split('=')[1];
                //传入了key
                if (key) {
                    if (item[item1]) {
                        //进入这个里面说明有相同的参数
                        flag = true;
                        key1 = item1;
                        item[item1] += value;
                    } else {
                        item[item1] = value;
                    }
                } 
                //未传入key
                else {
                    if (item[item1]) {
                        //进入这个里面说明有相同的参数
                        flag = true;
                        key1 = item1;
                        item[item1]+=value;
                    } else {
                        item[item1] = value;
                    }
                }
            }
    //当有key，且有相同的参数，且传入的key就是相同的参数时
            if (key && flag && key == key1) {
                return item[key1].split("");
            }
    //当有key，且有相同的参数，但传入的key不是相同的参数时
            if (key && flag && key != key1) {
                return item[key]?item[key]:"";
            }
    //当没有key，且有相同的参数
            if (!key && flag) {
                item[key1] = item[key1].split("")
                return item;
            }
    //当没有key的时候
            if (!key && !flag) {
                return item?item:{};
            }
}

function getUrlParam(sUrl, sKey) {
    let reg = /([^?&=]+)=([^?&=])/g
    let sKeys = sUrl.match(reg)

    let sKeyObjs = {}
    sKeys.forEach(item=>{
        let key = item.split("=")[0]
        let value = item.split("=")[1]
        if(!sKeyObjs[key]){
            sKeyObjs[key]=[]
        }
        sKeyObjs[key].push(value)
    })
    
    if(sKey === undefined){
        return sKeyObjs
    }else{
        let sKeyValues = []
        if(sKeyObjs[sKey]){
            sKeyValues = sKeyObjs[sKey]
        }
        return sKeyValues.length===0?"":sKeyValues.length>1?sKeyValues:sKeyValues[0]
    }
}

/([^?&=]+)=([^?&=])/g

  function getUrlParam(sUrl, sKey) {
      var start = sUrl.indexOf("?");
      if (start == -1) return null;
      var res = sUrl.substring(start + 1);
      var ressplit = res.split("&");
      var newarr = res.split("&").map(function(e) {
        var obj = {};
        var sp1 = e.split("=")[0];
        var sp2 = e.split("=")[1];
        obj[sp1] = sp2;
        return obj;
      });
      if (!sKey) return newarr;
      var newarr = newarr
        .filter(function(e) {
          return e["" + sKey + ""] != undefined;
        })
        .map(function(s) {
          return parseInt(s[sKey]) || s[sKey];
        });
      return newarr.length > 1 ? newarr : newarr.join("");
    }