GET පරාමිතීන්ගෙන් වටිනාකම ලබා ගන්නේ කෙසේද?

පහත දැක්වෙන පරිදි GET පරාමිතීන් සහිත URL මා සතුව ඇත:

www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5 

මට එහි සම්පූර්ණ වටිනාකම ලබා ගත යුතුයි c. මම URL එක කියවීමට උත්සාහ කළ නමුත් මට ලැබුණේ එය පමණි m2. ජාවාස්ක්‍රිප්ට් භාවිතයෙන් මා මෙය කරන්නේ කෙසේද?

ජාවාස්ක්රිප්ට් ම විමසුම string පරාමිතීන් කටයුතු සඳහා ඉදි කිසිවක් නැත.

(නවීන) බ්‍රව්සරයක කේත ධාවනය වන ඔබට URLවස්තුව භාවිතා කළ හැකිය (එය බ්‍රව්සර් විසින් JS වෙත සපයන API වල කොටසකි):

var url_string = "http://www.example.com/t.html?a=1&b=3&c=m2-m3-m4-m5"; //window.location.href
var url = new URL(url_string);
var c = url.searchParams.get("c");
console.log(c);

පැරණි බ්‍රව්සර් සඳහා (ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් ද ඇතුළුව), ඔබට මෙම පොලිෆිල් එක හෝ කේතය භාවිතා කළ හැකිය URL.

ඔබට ප්‍රවේශ විය හැකි අතර location.search, එමඟින් ඔබට ?URL සිට අවසානය දක්වා හෝ කොටස් හඳුනාගැනීමේ (#foo) ආරම්භය ලබා දෙනු ඇත.

එවිට ඔබට මෙය විග්‍රහ කළ හැකිය:

function parse_query_string(query) {
  var vars = query.split("&");
  var query_string = {};
  for (var i = 0; i < vars.length; i++) {
    var pair = vars[i].split("=");
    var key = decodeURIComponent(pair[0]);
    var value = decodeURIComponent(pair[1]);
    // If first entry with this name
    if (typeof query_string[key] === "undefined") {
      query_string[key] = decodeURIComponent(value);
      // If second entry with this name
    } else if (typeof query_string[key] === "string") {
      var arr = [query_string[key], decodeURIComponent(value)];
      query_string[key] = arr;
      // If third or later entry with this name
    } else {
      query_string[key].push(decodeURIComponent(value));
    }
  }
  return query_string;
}

var query_string = "a=1&b=3&c=m2-m3-m4-m5";
var parsed_qs = parse_query_string(query_string);
console.log(parsed_qs.c);

වත්මන් පිටුවේ URL වෙතින් ඔබට විමසුම් දාමය ලබා ගත හැකිය:

var query = window.location.search.substring(1);
var qs = parse_query_string(query);

මා දැක ඇති බොහෝ ක්‍රියාත්මක කිරීම් වල නම් සහ අගයන් URL විකේතනය කිරීම මග හැරේ.

නිසි URL- විකේතනය කරන සාමාන්‍ය උපයෝගිතා ශ්‍රිතයක් මෙන්න:

function getQueryParams(qs) {
    qs = qs.split('+').join(' ');

    var params = {},
        tokens,
        re = /[?&]?([^=]+)=([^&]*)/g;

    while (tokens = re.exec(qs)) {
        params[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]);
    }

    return params;
}

//var query = getQueryParams(document.location.search);
//alert(query.foo);

මූලාශ්රය

function gup( name, url ) {
    if (!url) url = location.href;
    name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
    var regexS = "[\\?&]"+name+"=([^&#]*)";
    var regex = new RegExp( regexS );
    var results = regex.exec( url );
    return results == null ? null : results[1];
}
gup('q', 'hxxp://example.com/?q=abc')

එක් පරාමිතියක් පමණක් පරීක්ෂා කිරීමට මෙය පහසු ක්‍රමයකි:

උදාහරණ URL:

http://myserver/action?myParam=2

උදාහරණ ජාවාස්ක්‍රිප්ට්:

var myParam = location.search.split('myParam=')[1]

URL හි "myParam" පවතී නම් ... විචල්ය myParam හි "2" අඩංගු වේ, එසේ නොමැති නම් එය නිර්වචනය නොකෙරේ.

සමහර විට ඔබට පෙරනිමි අගයක් අවශ්‍ය විය හැකිය, එවැනි අවස්ථාවක:

var myParam = location.search.split('myParam=')[1] ? location.search.split('myParam=')[1] : 'myDefaultValue';

යාවත්කාලීන කිරීම: මෙය වඩා හොඳින් ක්‍රියා කරයි:

var url = "http://www.example.com/index.php?myParam=384&login=admin"; // or window.location.href for current url
var captured = /myParam=([^&]+)/.exec(url)[1]; // Value is in [1] ('384' in our case)
var result = captured ? captured : 'myDefaultValue';

URL පරාමිතීන්ගෙන් පිරී තිබියදීත් එය නිවැරදිව ක්‍රියා කරයි.

බ්‍රව්සර් වෙළෙන්දෝ URL සහ URLSearchParams හරහා මෙය කිරීමට ස්වදේශීය ක්‍රමයක් ක්‍රියාත්මක කර ඇත.

let url = new URL('http://www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5');
let searchParams = new URLSearchParams(url.search);
console.log(searchParams.get('c'));  // outputs "m2-m3-m4-m5"

දැනට ෆයර්ෆොක්ස්, ඔපෙරා, සෆාරි, ක්‍රෝම් සහ එජ් සඳහා සහය දක්වයි. බ්‍රව්සර් සහාය ලැයිස්තුවක් සඳහා මෙහි බලන්න .

https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams https://developer.mozilla.org/en-US/docs/Web/API/URL/URL

https://url.spec.whatwg.org/

ගූගල් හි ඉංජිනේරුවෙකු වන එරික් බිඩෙල්මන් සහාය නොදක්වන බ්‍රව්සර් සඳහා මෙම පොලිෆිල් භාවිතා කිරීම නිර්දේශ කරයි .

මම මෙය අවුරුදු ගණනාවකට පෙර සොයා ගත්තා, ඉතා පහසුයි:

function getUrlVars() {
    var vars = {};
    var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi,    
    function(m,key,value) {
      vars[key] = value;
    });
    return vars;
  }

ඉන්පසු එය මේ ආකාරයට අමතන්න:

var fType = getUrlVars()["type"];

ඔබට විමසුම් දාමය ලබා ගත හැකිය location.search, පසුව ප්‍රශ්නාර්ථ ලකුණෙන් පසුව ඔබට සියල්ල බෙදිය හැකිය:

var params = {};

if (location.search) {
    var parts = location.search.substring(1).split('&');

    for (var i = 0; i < parts.length; i++) {
        var nv = parts[i].split('=');
        if (!nv[0]) continue;
        params[nv[0]] = nv[1] || true;
    }
}

// Now you can get the parameters you want like so:
var abc = params.abc;

මම වඩාත් සරල හා අලංකාර විසඳුමක් ලිව්වෙමි.

var arr = document.URL.match(/room=([0-9]+)/)
var room = arr[1];

URLSearchParams භාවිතා කරන සුපිරි සරල ක්‍රමයක් .

function getParam(param){
  return new URLSearchParams(window.location.search).get(param);
}

එය දැනට Chrome, Firefox, Safari, Edge සහ වෙනත් අය සඳහා සහය දක්වයි .

මෙන්න පුනරාවර්තන විසඳුමක් වන අතර එය අවම විකෘතියක් ඇත (පරාමිති වස්තුව පමණක් විකෘති වී ඇත, එය ජේඑස් හි නොවැලැක්විය හැකි යැයි මම විශ්වාස කරමි).

එය නියමයි:

• පුනරාවර්තන වේ
• එකම නමක පරාමිතීන් හසුරුවයි
• විකෘති පරාමිති නූල් සමඟ හොඳින් කටයුතු කරයි (නැතිවූ අගයන්, එසේ ය)
• '=' අගයෙහි තිබේ නම් කැඩී නොයයි
• URL විකේතනය සිදු කරයි
• අවසාන වශයෙන්, එය නියමයි ... ආහ් !!!

කේතය:

var get_params = function(search_string) {

  var parse = function(params, pairs) {
    var pair = pairs[0];
    var parts = pair.split('=');
    var key = decodeURIComponent(parts[0]);
    var value = decodeURIComponent(parts.slice(1).join('='));

    // Handle multiple parameters of the same name
    if (typeof params[key] === "undefined") {
      params[key] = value;
    } else {
      params[key] = [].concat(params[key], value);
    }

    return pairs.length == 1 ? params : parse(params, pairs.slice(1))
  }

  // Get rid of leading ?
  return search_string.length == 0 ? {} : parse({}, search_string.substr(1).split('&'));
}

var params = get_params(location.search);

// Finally, to get the param you want
params['c'];

මම මෙය කරන ශ්‍රිතයක් කළෙමි:

var getUrlParams = function (url) {
  var params = {};
  (url + '?').split('?')[1].split('&').forEach(function (pair) {
    pair = (pair + '=').split('=').map(decodeURIComponent);
    if (pair[0].length) {
      params[pair[0]] = pair[1];
    }
  });
  return params;
};

යාවත්කාලීන කිරීම 5/26/2017, මෙන්න ES7 ක්‍රියාත්මක කිරීමකි (බාබල් පෙර සැකසුම් අදියර 0, 1, 2, හෝ 3 සමඟ ධාවනය වේ):

const getUrlParams = url => `${url}?`.split('?')[1]
  .split('&').reduce((params, pair) =>
    ((key, val) => key ? {...params, [key]: val} : params)
    (...`${pair}=`.split('=').map(decodeURIComponent)), {});

සමහර පරීක්ෂණ:

console.log(getUrlParams('https://google.com/foo?a=1&b=2&c')); // Will log {a: '1', b: '2', c: ''}
console.log(getUrlParams('/foo?a=1&b=2&c')); // Will log {a: '1', b: '2', c: ''}
console.log(getUrlParams('?a=1&b=2&c')); // Will log {a: '1', b: '2', c: ''}
console.log(getUrlParams('https://google.com/')); // Will log {}
console.log(getUrlParams('a=1&b=2&c')); // Will log {}

3/26/2018 යාවත්කාලීන කරන්න, මෙන්න යතුරු ලියනය ක්‍රියාත්මක කිරීමකි:

const getUrlParams = (search: string) => `${search}?`
  .split('?')[1]
  .split('&')
  .reduce(
    (params: object, pair: string) => {
      const [key, value] = `${pair}=`
        .split('=')
        .map(decodeURIComponent)

      return key.length > 0 ? { ...params, [key]: value } : params
    },
    {}
  )

යාවත්කාලීන කිරීම 2/13/2019, මෙන්න ටයිප්ස්ක්‍රිප්ට් 3 සමඟ ක්‍රියා කරන යාවත්කාලීන කළ ටයිප්ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමකි.

interface IParams { [key: string]: string }

const paramReducer = (params: IParams, pair: string): IParams => {
  const [key, value] = `${pair}=`.split('=').map(decodeURIComponent)

  return key.length > 0 ? { ...params, [key]: value } : params
}

const getUrlParams = (search: string): IParams =>
  `${search}?`.split('?')[1].split('&').reduce<IParams>(paramReducer, {})

මේක බලන්න

function getURLParameters(paramName)
{
    var sURL = window.document.URL.toString();
    if (sURL.indexOf("?") > 0)
    {
        var arrParams = sURL.split("?");
        var arrURLParams = arrParams[1].split("&");
        var arrParamNames = new Array(arrURLParams.length);
        var arrParamValues = new Array(arrURLParams.length);

        var i = 0;
        for (i = 0; i<arrURLParams.length; i++)
        {
            var sParam =  arrURLParams[i].split("=");
            arrParamNames[i] = sParam[0];
            if (sParam[1] != "")
                arrParamValues[i] = unescape(sParam[1]);
            else
                arrParamValues[i] = "No Value";
        }

        for (i=0; i<arrURLParams.length; i++)
        {
            if (arrParamNames[i] == paramName)
            {
                //alert("Parameter:" + arrParamValues[i]);
                return arrParamValues[i];
            }
        }
        return "No Parameters Found";
    }
}

ECMAScript 6 විසඳුම:

var params = window.location.search
  .substring(1)
  .split("&")
  .map(v => v.split("="))
  .reduce((map, [key, value]) => map.set(key, decodeURIComponent(value)), new Map())

මම parseUri පුස්තකාලය භාවිතා කරමි . ඔබ ඉල්ලන දේ හරියටම කිරීමට එය ඔබට ඉඩ දෙයි:

var uri = 'www.test.com/t.html&a=1&b=3&c=m2-m3-m4-m5';
var c = uri.queryKey['c'];
// c = 'm2-m3-m4-m5'

මම පාවිච්චි කරනවා

function getVal(str) {
    var v = window.location.search.match(new RegExp('(?:[\?\&]'+str+'=)([^&]+)'));
    return v ? v[1] : null;
}

කෙටිම ක්‍රමය:

new URL(location.href).searchParams.get("my_key");

මෙන්න මගේ විසඳුම. මෙම ප්‍රශ්නයට පිළිතුරු දෙන අතරතුර ඇන්ඩි ඊ විසින් උපදෙස් දුන් පරිදි, තනි අගයක් ලබා ගැනීම සඳහා විවිධ රීජෙක්ස් නූල්, ධාවන ලූප යනාදිය නැවත නැවත ගොඩනඟන්නේ නම් එය ඔබේ ස්ක්‍රිප්ටයේ ක්‍රියාකාරිත්වයට හොඳ නැත. ඉතින්, මම සියලු GET පරාමිතීන් තනි වස්තුවක නැවත ලබා දෙන සරල පිටපතක් ඉදිරිපත් කර ඇත්තෙමි. ඔබ එය එක් වරක් පමණක් ඇමතිය යුතු අතර, ප්‍රති result ලය විචල්‍යයකට පැවරිය යුතු අතර අනාගතයේ ඕනෑම අවස්ථාවක සුදුසු යතුර භාවිතා කර එම විචල්‍යයෙන් ඔබට අවශ්‍ය ඕනෑම අගයක් ලබා ගත යුතුය. එය URI විකේතනය (එනම්% 20 වැනි දේවල්) ගැන සැලකිලිමත් වන අතර + වෙනුවට ඉඩක් ආදේශ කරයි:

 function getUrlQueryParams(url) {
  var queryString = url.split("?")[1];
  var keyValuePairs = queryString.split("&");
  var keyValue = [];
  var queryParams = {};
  keyValuePairs.forEach(function(pair) {
    keyValue = pair.split("=");
    queryParams[keyValue[0]] = decodeURIComponent(keyValue[1]).replace(/\+/g, " ");
});
  return queryParams;
}

ඉතින්, ඔබට බැලීමට පිටපතෙහි පරීක්ෂණ කිහිපයක් මෙන්න:

// Query parameters with strings only, no special characters.
var currentParams = getUrlQueryParams("example.com/foo?number=zero");
alert(currentParams["number"]); // Gives "zero".

// For the URL you stated above...
var someParams = getUrlQueryParams("www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5 ");
alert(someParams["c"]); // Gives "m2-m3-m4-m5".

// For a query params with URI encoding...
var someParams = getUrlQueryParams("www.example.com/t.html?phrase=a%20long%20shot&location=Silicon+Valley%2C+USA");
alert(someParams["phrase"]); // Gives "a long shot".
alert(someParams["location"]); // Gives "Silicon Valley, USA".

නැතහොත් ඔබට URI විග්‍රහ කිරීමේ රෝදය නවීකරණය කිරීමට අවශ්‍ය නැතිනම් URI.js භාවිතා කරන්න

Foo නම් පරාමිතියක වටිනාකම ලබා ගැනීම සඳහා:

new URI((''+document.location)).search(true).foo

එය කරන්නේ එයයි

1. Document.location එක නූලකට පරිවර්තනය කරන්න (එය වස්තුවකි)
2. URI.js හි URI පන්තියේ නිර්මාපකයාට එම නූල පෝෂණය කරන්න
3. යූආර්එල් හි සෙවුම් (විමසුම්) කොටස ලබා ගැනීම සඳහා සෙවුම් () ශ්‍රිතයට ආයාචනා කරන්න (
   සත්‍යය පසු කිරීමෙන් එය වස්තුවක් ප්‍රතිදානය කිරීමට කියයි)
4. වටිනාකම ලබා ගැනීම සඳහා ලැබෙන වස්තුව මත foo දේපල වෙත පිවිසෙන්න

මෙන්න මේ සඳහා ප්‍රහේලිකාවක් .... http://jsfiddle.net/m6tett01/12/

සඳහා තනි කම අගය මෙම index.html වගේ දෙයක්? Msg = 1 පහත දැක්වෙන කේතය භාවිතා,

$(window).load(function(){
    queryString();
});

function queryString()
{
    var queryString = window.location.search.substring(1);
    var varArray = queryString.split("="); //eg. index.html?msg=1

    var param1 = varArray[0];
    var param2 = varArray[1];

}

සඳහා සියලුම කම පහත දැක්වෙන කේතය අගය භාවිතය,

$(window).load(function(){
    queryString();
});

function queryString()
{
    var queryString = window.location.search;
    var varArray = queryString.split("&");
    for (var i=0;i<varArray.length;i++) {
      var param = varArray[i].split("=");
        //parameter-value pair
    }
} 

මෙන්න මම එක් උදාහරණයක් පළ කරමි. නමුත් එය jQuery හි ඇත. එය අන් අයට උපකාර කරනු ඇතැයි සිතමු:

<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="jquery.url.js"></script>

<!-- URL:  www.example.com/correct/?message=done&year=1990-->

<script type="text/javascript">
$(function(){
    $.url.attr('protocol')  // --> Protocol: "http"
    $.url.attr('path')          // --> host: "www.example.com"
    $.url.attr('query')         // --> path: "/correct/"
    $.url.attr('message')   // --> query: "done"
    $.url.attr('year')      // --> query: "1990"
});
</script>

මෙම ප්‍රශ්නයට පිළිතුරු ඕනෑවටත් වඩා ඇත, එබැවින් මම තවත් එකක් එකතු කරමි.

/**
 * parses and returns URI query parameters 
 * 
 * @param {string} param parm
 * @param {bool?} asArray if true, returns an array instead of a scalar 
 * @returns {Object|Array} 
 */
function getURIParameter(param, asArray) {
    return document.location.search.substring(1).split('&').reduce(function(p,c) {
        var parts = c.split('=', 2).map(function(param) { return decodeURIComponent(param); });
        if(parts.length == 0 || parts[0] != param) return (p instanceof Array) && !asArray ? null : p;
        return asArray ? p.concat(parts.concat(true)[1]) : parts.concat(true)[1];
    }, []);
}

භාවිතය:

getURIParameter("id")  // returns the last id or null if not present
getURIParameter("id", true) // returns an array of all ids

මෙය හිස් පරාමිතීන් සමඟ (එම යතුරු නොමැතිව පවතී "=value"), පරිමාණ සහ අරාව මත පදනම් වූ අගය ලබා ගැනීමේ API දෙකම නිරාවරණය කිරීම මෙන්ම නිසි URI සංරචක විකේතනය සමඟ කටයුතු කරයි.

ක්රමය භාවිතා කිරීමට පහසුම replace()ක්රමය:

සිට urlStrසොයමු:

paramVal = urlStr.replace(/.*param_name=([^&]*).*|(.*)/, '$1');

හෝ වත්මන් URL වෙතින් :

paramVal = document.URL.replace(/.*param_name=([^&]*).*|(.*)/, '$1');

පැහැදිලි කිරීම:

• document.URL - අතුරුමුහුණත ලේඛනයේ පිහිටීම (පිටු url) නූලක් ලෙස ලබා දෙයි.
• replace()- ක්රමය කිහිපයක් හෝ සියල්ලම තරග සමග නව අගයක් ප්රතිදානය රටාව මගින් විස්ථාපනය වෙනුවට .
• /.*param_name=([^&]*).*/- කප්පාදුව අතර කොටු කර ඇති නිත්‍ය ප්‍රකාශන රටාව:
  • .* - ඕනෑම අක්ෂර ශුන්‍ය හෝ වැඩි ගණනක්,
  • param_name= - සේවය කරන පරම් නම,
  • () - නිත්‍ය ප්‍රකාශනයේ සමූහය,
  • [^&]*- හැර වෙනත් ඕනෑම අක්ෂර එකක් හෝ කිහිපයක් &,
  • | - විකල්ප,
  • $1 - නිත්‍ය ප්‍රකාශනයේ පළමු කණ්ඩායම වෙත යොමු කිරීම.

var urlStr = 'www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5';
var c = urlStr.replace(/.*c=([^&]*).*|(.*)/, '$1');
var notExisted = urlStr.replace(/.*not_existed=([^&]*).*|(.*)/, '$1');
console.log(`c === '${c}'`);
console.log(`notExisted === '${notExisted}'`);

තවත් යෝජනාවක්.

දැනටමත් හොඳ පිළිතුරු කිහිපයක් ඇත, නමුත් ඒවා අනවශ්‍ය ලෙස සංකීර්ණ හා තේරුම් ගැනීමට අපහසු බව මට පෙනී ගියේය. මෙය කෙටි, සරල වන අතර URL හි ටෝකන නාමයන්ට අනුරූප වන ප්‍රධාන නම් සහිත සරල සහායක පෙළක් ලබා දෙයි.

ඉගෙනීමට කැමති අය සඳහා මම පහත අදහස් දැක්වීම් සහිත අනුවාදයක් එක් කළෙමි.

මෙය සෑම ලූපයක් වෙනුවට මම නිර්දේශ කරන එහි ලූපය සඳහා jQuery ($ .each) මත රඳා පවතින බව සලකන්න. පැරණි බ්‍රව්සර්වල නව කාර්යයන් සඳහා සහය නොදක්වන ඕනෑම දෙයකට සහය දැක්වීම සඳහා තනි විසඳුම් සවි කිරීම වෙනුවට පුවරුව හරහා jQuery භාවිතා කරමින් හරස් බ්‍රව්සර් අනුකූලතාව සහතික කිරීම සරල බව මට පෙනේ.

සංස්කරණය කරන්න: මම මෙය ලිවීමෙන් පසු එරික් එලියට්ගේ පිළිතුර සෑම එකක් සඳහාම භාවිතා කළත් එය බොහෝ දුරට සමාන ය, මම සාමාන්‍යයෙන් විරුද්ධ වන අතර (ඉහත සඳහන් හේතු නිසා).

function getTokens(){
    var tokens = [];
    var query = location.search;
    query = query.slice(1);
    query = query.split('&');
    $.each(query, function(i,value){    
        var token = value.split('=');   
        var key = decodeURIComponent(token[0]);     
        var data = decodeURIComponent(token[1]);
        tokens[key] = data;
    });
    return tokens;
}

අදහස් දැක්වූ අනුවාදය:

function getTokens(){
    var tokens = [];            // new array to hold result
    var query = location.search; // everything from the '?' onward 
    query = query.slice(1);     // remove the first character, which will be the '?' 
    query = query.split('&');   // split via each '&', leaving us an array of something=something strings

    // iterate through each something=something string
    $.each(query, function(i,value){    

        // split the something=something string via '=', creating an array containing the token name and data
        var token = value.split('=');   

        // assign the first array element (the token name) to the 'key' variable
        var key = decodeURIComponent(token[0]);     

        // assign the second array element (the token data) to the 'data' variable
        var data = decodeURIComponent(token[1]);

        tokens[key] = data;     // add an associative key/data pair to our result array, with key names being the URI token names
    });

    return tokens;  // return the array
}

පහත උදාහරණ සඳහා අපි මෙම ලිපිනය උපකල්පනය කරමු:

http://www.example.com/page.htm?id=4&name=murray

ඔබට ඔබේම විචල්‍යයට URL ටෝකන ලබා දිය හැකිය:

var tokens = getTokens();

ඉන්පසු එක් එක් URL ටෝකනය මේ ආකාරයෙන් යොමු කරන්න:

document.write( tokens['id'] );

මෙය "4" මුද්‍රණය කරයි.

ඔබට සෘජුවම ශ්‍රිතයෙන් aa ටෝකන් නාමයක් යොමු කළ හැකිය:

document.write( getTokens()['name'] );

... එය "මරේ" මුද්‍රණය කරයි.

// Read a page's GET URL variables and return them as an associative array.
function getUrlVars()
{
    var vars = [], hash;
    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
    for(var i = 0; i < hashes.length; i++)
    {
        hash = hashes[i].split('=');
        vars.push(hash[0]);
        vars[hash[0]] = hash[1];
    }
    return vars;
}

// Usage for URL: http://my.site.com/location?locationId=53cc272c0364aefcb78756cd&shared=false
var id = getUrlVars()["locationId"];

මෙතැනින් ලබා ගත්තා: http://jquery-howto.blogspot.ru/2009/09/get-url-parameters-values-with-jquery.html

සරල ක්‍රමය

function getParams(url){
        var regex = /[?&]([^=#]+)=([^&#]*)/g,
            params = {},
            match;
        while(match = regex.exec(url)) {
            params[match[1]] = match[2];
        }
        return params;
    }

getParams (url) ලෙස අමතන්න

අලංකාර, ක්‍රියාකාරී ශෛලීය විසඳුම

යූආර්එල් පරාමි නම් යතුරු ලෙස වස්තුවක් නිර්මාණය කරමු, එවිට අපට පහසුවෙන් පරාමිතිය එහි නමින් උකහා ගත හැකිය:

// URL: https://example.com/?test=true&orderId=9381  

// Build an object containing key-value pairs
export const queryStringParams = window.location.search
  .split('?')[1]
  .split('&')
  .map(keyValue => keyValue.split('='))
  .reduce<QueryStringParams>((params, [key, value]) => {
    params[key] = value;
    return params;
  }, {});

type QueryStringParams = {
  [key: string]: string;
};


// Return URL parameter called "orderId"
return queryStringParams.orderId;

මට URL GET විචල්‍යයක් කියවා url පරාමිතිය මත පදනම්ව ක්‍රියාවක් සම්පූර්ණ කිරීමේ අවශ්‍යතාවය තිබුණි. මම විසඳුමක් සඳහා ඉහළ සහ පහත් සෙවූ අතර මෙම කුඩා කේත කැබැල්ල හමු විය. එය මූලික වශයෙන් වර්තමාන පිටු url කියවන අතර, URL හි යම් නිත්‍ය ප්‍රකාශනයක් සිදු කර පසුව අපට පහසුවෙන් ප්‍රවේශ විය හැකි සහායක අරාව තුළ url පරාමිතීන් සුරකිනු ඇත.

උදාහරණයක් ලෙස, පහත දැක්වෙන url එක ජාවාස්ක්‍රිප්ට් සමඟ පතුලේ තිබේ නම්.

http://TestServer/Pages/NewsArchive.aspx?year=2013&Month=July

පරාමිති හැඳුනුම්පත සහ පිටුව ලබා ගැනීම සඳහා අප කළ යුත්තේ මෙය අමතන්න:

කේතය වනුයේ:

<script type="text/javascript">
var first = getUrlVars()["year"];
var second = getUrlVars()["Month"];

alert(first);
alert(second);
function getUrlVars() {
var vars = {};
var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) {
vars[key] = value;
});
return vars;
}
</script>

// http:localhost:8080/path?param_1=a&param_2=b
var getParamsMap = function () {
    var params = window.location.search.split("&");
    var paramsMap = {};
    params.forEach(function (p) {
        var v = p.split("=");
        paramsMap[v[0]]=decodeURIComponent(v[1]);
    });
    return paramsMap;
};

// -----------------------

console.log(getParamsMap()["param_1"]);  // should log "a"     

එල්ඩන් මැක්ගිනස් විසින් රචිත මෙම සාරාංශය, මම මෙතෙක් දැක ඇති ජාවාස්ක්‍රිප්ට් විමසුම් නූල් විග්‍රහකය වඩාත් සම්පූර්ණ ලෙස ක්‍රියාත්මක කිරීමකි.

අවාසනාවට, එය jQuery ප්ලගිනයක් ලෙස ලියා ඇත.

මම එය වැනිලා ජේඑස් වෙත නැවත ලියා වැඩි දියුණු කිරීම් කිහිපයක් කළෙමි:

function parseQuery(str) {
  var qso = {};
  var qs = (str || document.location.search);
  // Check for an empty querystring
  if (qs == "") {
    return qso;
  }
  // Normalize the querystring
  qs = qs.replace(/(^\?)/, '').replace(/;/g, '&');
  while (qs.indexOf("&&") != -1) {
    qs = qs.replace(/&&/g, '&');
  }
  qs = qs.replace(/([\&]+$)/, '');
  // Break the querystring into parts
  qs = qs.split("&");
  // Build the querystring object
  for (var i = 0; i < qs.length; i++) {
    var qi = qs[i].split("=");
    qi = qi.map(function(n) {
      return decodeURIComponent(n)
    });
    if (typeof qi[1] === "undefined") {
      qi[1] = null;
    }
    if (typeof qso[qi[0]] !== "undefined") {

      // If a key already exists then make this an object
      if (typeof (qso[qi[0]]) == "string") {
        var temp = qso[qi[0]];
        if (qi[1] == "") {
          qi[1] = null;
        }
        qso[qi[0]] = [];
        qso[qi[0]].push(temp);
        qso[qi[0]].push(qi[1]);

      } else if (typeof (qso[qi[0]]) == "object") {
        if (qi[1] == "") {
          qi[1] = null;
        }
        qso[qi[0]].push(qi[1]);
      }
    } else {
      // If no key exists just set it as a string
      if (qi[1] == "") {
        qi[1] = null;
      }
      qso[qi[0]] = qi[1];
    }
  }
  return qso;
}

// DEMO
console.log(parseQuery("?foo=bar&foo=boo&roo=bar;bee=bop;=ghost;=ghost2;&;checkbox%5B%5D=b1;checkbox%5B%5D=b2;dd=;http=http%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dst%C3%A5le%26car%3Dsaab&http=http%3A%2F%2Fw3schools2.com%2Fmy%20test.asp%3Fname%3Dst%C3%A5le%26car%3Dsaab"));

මෙම ෆෙඩෙල් ද බලන්න .

මෙන්න මම කරන දේ:

var uriParams = getSearchParameters();
alert(uriParams.c);


// background functions:

// Get object/associative array of URL parameters
function getSearchParameters () {
  var prmstr = window.location.search.substr(1);
  return prmstr !== null && prmstr !== "" ? transformToAssocArray(prmstr) : {};
}

// convert parameters from url-style string to associative array
function transformToAssocArray (prmstr) {
  var params = {},
      prmarr = prmstr.split("&");

  for (var i = 0; i < prmarr.length; i++) {
    var tmparr = prmarr[i].split("=");
    params[tmparr[0]] = tmparr[1];
  }
  return params;
}