获取 url 参数

function getUrlParam(sUrl, sKey) {
    var index1 = sUrl.indexOf('?');
    var index2 = sUrl.indexOf('#');
    var sUrlTar = sUrl.slice(index1+1,index2).split('&');
    if(!sKey){
        var newObj ={}
         sUrlTar.forEach((elm) => {
            if (!(elm.split('=')[0] in newObj)) {
                    newObj[elm.split('=')[0]] = []
                }
                newObj[elm.split('=')[0]].push(elm.split('=')[1])
         })
        return newObj
     }
    var ans = [];
    sUrlTar.forEach((item) => {
        if(item.indexOf(sKey + '=') === 0){
            ans.push(item.slice(item.indexOf('=')+1,item.length))
        }
    })

    return ans.length === 0 ? '': ans.length === 1? ans[0]:ans
    
}

function getUrlParam(sUrl, sKey) {
    const Param = {}
    //获得参数段
    var arr=sUrl.split('?')[1].split('#')[0].split('&')
    for (let key of arr){
        //k为参数,v为值
        let k = key.split('=')[0]
        let v = key.split('=')[1]
        if(!Param[k]){
            Param[k] = v
        }else{
            Param[k] = Array.from(Param[k]).concat(v)
        }
    }
    return sKey===void 0 ? Param : Param[sKey] || ''
}

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) {
    let result = [];
    const entries = new URL(sUrl).searchParams.entries();
    for (let entry of entries) {
        result.push(entry);
    }
    
    if (sKey) {
        const filtered = result.filter((entry) => {
            if (entry[0] === sKey) {
                return true;
            }
            return false;
        });
        if (filtered.length === 0) {
            return '';
        }
        if (filtered.length === 1) {
            return filtered[0][1] || ''
        } else {
            return filtered.map((v) => {
                return v[1] || ''
            })
        }
    } else {
        return result.reduce((rs, next) => {
            return {
                [next[0]]: next[1],
                ...rs
            }
        }, {})
    }
}

不知道哪里出了问题，75%的用例通过，大佬们帮忙看下呗

function getUrlParam(sUrl, sKey) {
    let params = sUrl.split('#')[0].split("?")[1]  // 获取参数
    if(sKey) {  // 如果指定了参数
        let tar = params.split('&');
        let arr = []
        for(let i =0;i<tar.length;i++) {
            let flag = tar[i].includes(sKey);
            if(flag) {
                arr.push(tar[i])
            }
        }
        if(arr.length>0) {
            let array = [];
            for(let i=0;i<arr.length;i++) {
                let data = arr[i].split('=')[1]
                array.push(data)
            }
            return array
        }else{
            return ''
        }
    } else{
        if(params == '' || params == undefined) {
            return {}
        } else{
            let res = {}
            let target = params.split('&');
            for(let i =0; i<target.length;i++) {
                let temp = target[i].split('=')
                if(!(temp[0] in res )) {
                    res[temp[0]] = []
                }
                res[temp[0]].push(temp[1])
            }
            return res
        }
            
    }
}

function getUrlParam(sUrl, sKey) {
    sUrl = sUrl.replace(/.{0,}\?|\#.{0,}/g, '').replace(/&/g, ' ')
    
    if (sKey) {
        const list = []

        sUrl.replace(
            new RegExp(`(${sKey})=(\\S)`, 'g'),
            (p1, p2, p3) => list.push(p3)
        )
        return list.length ? (list.length === 1 ? list[0] : list) : ''
    } else {
        const obj = {}
        console.log(sUrl)
        sUrl.replace(
            /(\S{0,})=(\S{0,})/g,
            (p1, p2, p3) => obj[p2] = obj[p2] ? [].concat(obj[p2], p3) : p3
        )
        return obj
    }
}

function getUrlParam(sUrl, sKey) {
    // 拆分参数数组['key=1','key=2','key=3','test=4']
    const urlStrArray = sUrl.split('?')[1].split('#')[0].split('&');
    // 参数对象
    const searchObj = {};
    urlStrArray.forEach(item=>{
        // 按等号拆分每个参数，获取key和value
        const oneArray = item.split('=')
        const key = oneArray[0]
        const value = oneArray[1]
       // 如果参数对象中已经有该key，说明参数名重复
       if(searchObj.hasOwnProperty(key)) {
         const oldValue = searchObj[key]
         // 如果存储的值为字符串，则改为数组，将新值存入
         if(typeof oldValue === 'string'){
            searchObj[key] = [oldValue, value];
         }else{
            // 否则说明已经重复过，该值是一个数组，直接push新值
            searchObj[key].push(value)
         }
       }else{
         // 参数名未出现过，直接存入
         searchObj[key]=value
       }
    })
    // 指定参数名称查询，返回参数值，参数不存在时返回空字符串
    if(sKey){
       return searchObj[sKey]?searchObj[sKey]:''
    }else{
        // 不指定直接返回所有参数
       return searchObj
    }
}

function getUrlParam(url, wd) {
    const str = url.substring(24, url.length - 5).trim();
    const arr = str.split("&");
    let arr1 = [];
    let arr2 = []
    for (let i = 0; i < arr.length; i++) {
        arr1[i] = arr[i].split("=")
    }
    arr1.forEach(element => {
        for (let i = 0; i < element.length; i++){
            if (element[i] === wd) {
               arr2 = element[i+1];
            }
        }
    })
    return arr2;
}
// 为什么不能提交啊，

function getUrlParam(sUrl, sKey) {
  if (!sUrl) {
    return
  }
  let result = [] // 保存有key的结果
  let noKeyResult = {} // 保存没有key的结果
  // 改造成key=1&key=2&key=3&test=4#hehe
  sUrl = sUrl.split('?')[1]
  if (sUrl.indexOf('#') != -1) {
    // 改造成key=1&key=2&key=3&test=4
    sUrl = sUrl.split('#')[0]
  }
  // 改造成[key=1,key=2,key=3,test=4]
  sUrl = sUrl.split('&')
  // 改造成[{key:1},{key:2},{key:3},{test:4}]
  sUrl.forEach((v, i) => {
    v = v.split('=')
    key = v[0]  // key key key test
    value = v[1] // 1 2 3 4
    // 对有传入key的进行处理
    if (sKey === key) { // 如果key和传入的skey相同，则放入有skey的数组
      result.push(value)
    }
    // 对没有传入key的进行处理
    if (!noKeyResult[key]) { // 如果匹配到该key是第一次出现，则需要在对象中创建该属性，且值为一个数组
      noKeyResult[key] = [value]
    } else {
      noKeyResult[key].push(value) // 如果存在，则直接添加数据即可
    }
    
  })
  // 没有skey的情况
  if (!sKey) {
    return noKeyResult
  } else {
     // 有sKey的情况
    if (result.length > 1) {
      return result
    } else {
      // 需要特别注意的是当skey虽然存在但没有匹配到URL中任何一个参数的时候，需要返回一个空字符串
      return result[0] || ''
    }
  }
}

function getUrlParam(sUrl, sKey) {
    var parmas = new URL(sUrl).search.split('?')[1].split('&')
    var obj = {}
    for (var i = 0; i < parmas.length; i++) {
        var [key, value] = parmas[i].split('=')
        if (obj[key] === undefined) {
            obj[key] = value
        } else {
            obj[key] = [].concat(obj[key], value)
        }
    }

    return sKey === undefined ? obj : obj[sKey] || ''
}

function getUrlParam(sUrl, sKey) {
    let parmsStr = sUrl.split('?').pop().split('#').shift()
    let mapList = parmsStr.split('&').reduce((count, item) => {
        let [key, value] = item.split('=')
        if (count.hasOwnProperty(key) && !Array.isArray(count[key])) {
            count[key] = [count[key], value]
        } else if (count.hasOwnProperty(key) && Array.isArray(count[key])) {
            count[key].push(value)
        } else {
            count[key] = value
        }
        return count
    }, {})
    if (!sKey) return mapList
    return mapList[sKey] || ''
}