获取 url 参数

function getUrlParam(sUrl, sKey) {
    var params = sUrl.split('?')[1].split('#')[0].split('&');
    var obj = {};

    params.forEach(el=>{
        if (Object.keys(obj).includes(el.split('=')[0])) {
            obj[el.split('=')[0]] = obj[el.split('=')[0]].concat(el.split('=')[1]);
        } else {
            obj[el.split('=')[0]] = [].concat(el.split('=')[1]);
        }   
    });

    if(sKey){
        if(!obj[sKey]){
            return ''; 
        }else{
            switch(obj[sKey].length){
                case 1:
                    return obj[sKey][0];
                    break;
                default:
                    return obj[sKey];
                    break;
            }
        }
    }else{
        return obj;
    }
}

function getUrlParam(sUrl, sKey) {
    var keyArr = sUrl.split('?')[1].split('#')[0].split('&')
    var keyObj = {}
    for (var item of keyArr) {
        var [i, j] = item.split('=')
        if (!keyObj[i]) keyObj[i] = j
        else keyObj[i] = [...keyObj[i], j]
    }
    return !sKey ? keyObj : keyObj[sKey] || ''
}

/* 
  描述
  获取 url 中的参数
  1. 指定参数名称，返回该参数的值 或者 空字符串
  2. 不指定参数名称，返回全部的参数对象 或者 {}
  3. 如果存在多个同名参数，则返回数组
  4. 不支持URLSearchParams方法
*/


function getUrlParam(sUrl, sKey) {
  // // 分割字符串成数组，需要注意的是 # 后的字符串不属于参数
  // const start = sUrl.indexOf('?')
  // const end = sUrl.indexOf('#') < 0 ? sUrl.length : sUrl.indexOf('#')
  // // 处理url中没有参数的情况
  // if (start === -1) {
  //   return '该url中没有参数'
  // }
  // // 裁剪参数字符串，比如像 key=1&key=2&key=3&test=4
  // const paramsStr = sUrl.slice(start + 1, end)
  // // 分割成Array[array], 比如像 [ [ 'key', '1' ], [ 'key', '2' ], [ 'key', '3' ], [ 'test', '4' ] ]
  // const sArr = paramsStr.split('&').map(s => s.split('='))

  // 处理url中没有参数的情况
  if (!sUrl.split('?')[1]) {
    return '该url中没有参数'
  }

  const sArr = sUrl.split('?')[1].split('#')[0].split('&').map(s => s.split('='))
  const obj = {} // 用于存放参数

  for (const [prop, value] of sArr) {
    // 因为对象的key可能会重复，会覆盖掉之前相同key的值，根据对象key唯一性，使用数组来存储
    if (!obj[prop]) {
      obj[prop] = [value]
    } else {
      obj[prop].push(value)
    }
  }

  for (key in obj) {
    // 处理长度为1的key，使其恢复 key: value 的格式
    obj[key].length === 1 && (obj[key] = obj[key][0])
  }

  if (sKey && obj[sKey]) {
    // 指定参数名称且在url中找到该参数有值
    return obj[sKey]
  } else if (sKey && !obj[sKey]) {
    // 指定参数名称但是在url中找不到该参数
    return ''
  } else {
    // 不指定参数名称则返回url中所有的参数
    return obj
  }
}

// test
// const sKey = 'helloworld'
// const sUrl = 'http://www.nowcoder.com/'
const sUrl = 'http://www.nowcoder.com?key=1&key=2&key=3&test=4#here'
const sKey = ''
console.log('运行结果: ', getUrlParam(sUrl, sKey))

// 这个采用了类型判断的方式来处理，当遇见重复的 key 的问题
// 当检测到重复的时候 并且 类型还是 string 的时候把当前值改为 [原来的值和，第二次值]
// 再进来就是数组了然后直接 push 
// 貌似风险更低
function getUrlParam(url, sKey) {
    let startIndex = url.indexOf("?");
    let endIndex = url.indexOf("#");
    let str = url.substring(startIndex + 1, endIndex);
    let arr = str.split("&");
    //
    let ret = {};
    arr.forEach((item) => {
        let [key, val] = item.split("=");
        // 当前对象中不存在重复的值
        if (ret[key] === undefined) {
            ret[key] = val;
        } else {
            // 如果是string 就变成数组
            if (typeof ret[key] === "string") {
                // 原来的值与当前的值合并成一个数组
                ret[key] = [ret[key], val];
            } else if (Array.isArray(ret[key])) {
                ret[key].push(val);
            }
        }
    });
    return sKey ? ret[sKey] || "" : ret;
}

function getUrlParam(sUrl, sKey = "") {
      let reg = /[?&](.+)[&#]/i
      let matchedGroup = sUrl.match(reg)
        
      if(!sKey){  
           let arrOfValues = matchedGroup[1].split('&').map(item=>{
             let [key,value] = item.split("=")
             return value
           })   
           
          return {
              key: [...new Set(arrOfValues)]
          } 
      } else {
          let arrOfValues = matchedGroup[1].split('&').map(item => {
              let [key,value]= item.split('=')
              if(key === sKey){
                  return value
                 } else {
                     return undefined
                 }
              }    
          )
          
          
          let filtered = arrOfValues.filter(item => item!== undefined)
          if(filtered.length === 0){
              return ""
          } else if(filtered.length === 1) {
              return filtered.toString()
          } else {
              return filtered
          }
              
      }     
}

function getUrlParam(sUrl, sKey) {
   var str = sUrl.slice(sUrl.indexOf('?')+1,sUrl.length)
   		str = str.slice(0,str.indexOf('#'))
   		str = str.split('&')
   		var a=[];
   		for(var i=0; i<str.length; i++){
   			// console.log(str[i])
   			if (str[i].indexOf(sKey) !== -1 && !sKey) {
   				a.push(parseInt(str[i].split('=')[1]))
   			}else {
   				a.push(parseInt(str[i].split('=')[1]))
   			}
   		}
   		return a;
   
}

不通过啊

不用正则
function getUrlParam(sUrl, sKey) {
    let para=sUrl.split("?")[1].split("#")[0].split("&")
    const obj={}
    for(let i=0;i<para.length;i++){
        let key=para[i].split('=')[0]
        let value=para[i].split("=")[1]
        if(!obj[key]){ 
                     obj[key]=value
                     }
        else{  
            obj[key]=[].concat(obj[key],value)
            
            }
        
    }
    return   !sKey?obj :obj[sKey]||""
    
}

function getUrlParam(sUrl, sKey) {
    let params = sUrl
    .split("?")[1]
    .split("#")[0]
    .split("&")
    .reduce((acc, cur) => {
        let [key, value] = cur.split("=");
        acc[key] = acc[key] ? [...acc[key], value] : value;
        return acc;
    }, {});

    if (sKey) {
        return params[sKey] || "";
    } else {
        return params || {};
    }
}

function getUrlParam(sUrl, sKey) {
    let obj = {}                                                                            
    for (let i of sUrl.match(/\w+(=\w)/g)) {    //遍历出所有的参数                                            
        let o = i.match(/^\w+/)[0]              //保存参数名                                           
        obj[o] ? obj[o].push(i.match(/\w+$/)[0]) : obj[o] = [i.match(/\w+$/)[0]]            
    }   //判断是否已存在该属性，如果不存在直接添加，如果存在则push进去                                                                                    
    return !sKey ? obj : !obj[sKey] ? '' : obj[sKey].length > 1 ? obj[sKey] : obj[sKey][0]          
}  //判断是否有传入sKey，如果没有返回obj，如果有sKey再判段该属性是否只有一个值，如果有多个值返回数组，如果只有一个值返回字符串