Jak uzyskać wartość z parametrów GET?

Mam adres URL z niektórymi parametrami GET w następujący sposób:

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

Muszę uzyskać całą wartość c. Próbowałem odczytać adres URL, ale dostałem tylko m2. Jak to zrobić za pomocą JavaScript?

Sam JavaScript nie ma nic wbudowanego do obsługi parametrów ciągu zapytania.

Kod działający w (nowoczesnej) przeglądarce można użyć URLobiektu (który jest częścią interfejsów API udostępnianych przez przeglądarki JS):

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

W przypadku starszych przeglądarek (w tym Internet Explorera) możesz użyć tego wypełnienia lub kodu z oryginalnej wersji tej odpowiedzi, która poprzedza URL:

Możesz uzyskać dostęp location.search, co da ci ?znak od końca do adresu URL lub początku identyfikatora fragmentu (#foo), w zależności od tego, co nastąpi wcześniej.

Następnie możesz to przeanalizować za pomocą tego:

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

Możesz pobrać ciąg zapytania z adresu URL bieżącej strony za pomocą:

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

Większość implementacji, które widziałem, pomija dekodowanie adresów URL nazw i wartości.

Oto ogólna funkcja narzędziowa, która również poprawnie dekoduje adresy 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);

źródło

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

Jest to prosty sposób na sprawdzenie tylko jednego parametru:

Przykładowy adres URL:

    http://myserver/action?myParam=2

Przykładowy Javascript:

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

jeśli w adresie URL istnieje „myParam”… zmienna myParam będzie zawierać „2”, w przeciwnym razie będzie niezdefiniowana.

Być może chcesz domyślną wartość, w takim przypadku:

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

Aktualizacja: Działa to lepiej:

    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';

I działa poprawnie, nawet jeśli adres URL jest pełen parametrów.

Dostawcy przeglądarek zaimplementowali natywny sposób, aby to zrobić za pomocą URL i 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"

Obecnie obsługiwany w Firefox, Opera, Safari, Chrome i Edge. Lista obsługiwanych przeglądarek znajduje się tutaj .

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/

Eric Bidelman, inżynier z Google, zaleca stosowanie tego wypełnienia w nieobsługiwanych przeglądarkach.

Znalazłem to wieki temu, bardzo łatwe:

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

Następnie nazwij to tak:

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

Możesz pobrać ciąg zapytania location.search, a następnie możesz podzielić wszystko po znaku zapytania:

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;

Napisałem prostsze i eleganckie rozwiązanie.

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

Bardzo prosty sposób za pomocą URLSearchParams .

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

Jest obecnie obsługiwany w Chrome, Firefox, Safari, Edge i innych .

Oto rekurencyjne rozwiązanie, które nie ma wyrażenia regularnego i ma minimalną mutację (mutowany jest tylko obiekt params, co moim zdaniem jest nieuniknione w JS).

To niesamowite, ponieważ:

• Jest rekurencyjny
• Obsługuje wiele parametrów o tej samej nazwie
• Dobrze radzi sobie ze źle sformułowanymi ciągami parametrów (brakujące wartości itd.)
• Nie pęka, jeśli wartość „=” jest podana
• Wykonuje dekodowanie adresu URL
• I wreszcie, jest niesamowity, ponieważ ... argh !!!

Kod:

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'];

Stworzyłem funkcję, która to robi:

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;
};

Aktualizacja 26.05.2017, oto implementacja ES7 (działa ze wstępnie ustawionymi etapami 0, 1, 2 lub 3 w Babel):

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

Niektóre testy:

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 {}

Aktualizacja 26.03.2018, oto implementacja maszynopisu:

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
    },
    {}
  )

Aktualizacja 13.02.2019, oto zaktualizowana implementacja TypeScript, która współpracuje z TypeScript 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, {})

Zobacz

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";
    }
}

Rozwiązanie 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())

używam

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

Korzystam z biblioteki parseUri . Pozwala robić dokładnie to, o co prosisz:

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'

Oto moje rozwiązanie. Jak sugeruje Andy E., odpowiadając na to pytanie , nie jest dobre dla wydajności skryptu, jeśli wielokrotnie buduje różne ciągi regularne, uruchamia pętle itp. Tylko po to, aby uzyskać pojedynczą wartość. Tak więc opracowałem prostszy skrypt, który zwraca wszystkie parametry GET w jednym obiekcie. Powinieneś wywołać go tylko raz, przypisać wynik do zmiennej, a następnie w dowolnym momencie w przyszłości uzyskać dowolną wartość z tej zmiennej za pomocą odpowiedniego klucza. Zauważ, że zajmuje się także dekodowaniem URI (tj.% 20) i zastępuje + spacją:

 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;
}

Oto kilka testów skryptu, które można zobaczyć:

// 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".

Lub jeśli nie chcesz wymyślać koła analizującego URI, użyj URI.js

Aby uzyskać wartość parametru o nazwie foo:

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

To co to robi

1. Konwertuj document.location na ciąg znaków (jest to obiekt)
2. Podaj ten ciąg do konstruktora klasy URI.js URI
3. Wywołaj funkcję search (), aby uzyskać część adresu URL dotyczącą wyszukiwania (zapytania)
   (przekazanie wartości true powoduje, że obiekt wypisuje obiekt)
4. Uzyskaj dostęp do właściwości foo na wynikowym obiekcie, aby uzyskać wartość

Oto skrzypce do tego .... http://jsfiddle.net/m6tett01/12/

W przypadku wartości parametru pojedynczego, takiego jak index.html? Msg = 1 użyj następującego kodu,

$(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];

}

Dla wartości wszystkich parametrów należy stosować następujący kod,

$(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
    }
} 

Tutaj zamieszczam jeden przykład. Ale jest w jQuery. Mam nadzieję, że pomoże innym:

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

Najkrótsza droga:

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

to pytanie ma zbyt wiele odpowiedzi, więc dodaję kolejne.

/**
 * 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];
    }, []);
}

stosowanie:

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

radzi sobie to z pustymi parametrami (te klucze są obecne bez "=value"), ujawnieniem zarówno API skalarnego, jak i opartego na tablicach API pobierania wartości, a także prawidłowym dekodowaniem komponentu URI.

Najłatwiejszy sposób przy użyciu replace()metody:

Z urlStrciągu:

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

lub z bieżącego adresu URL :

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

Wyjaśnienie:

• document.URL - interfejs zwraca lokalizację dokumentu (URL strony) jako ciąg znaków.
• replace() - metoda zwraca nowy ciąg z niektórymi lub wszystkimi dopasowaniami a wzorca zastąpionymi zamiennikiem .
• /.*param_name=([^&]*).*/- wzorzec wyrażenia regularnego zamknięty między ukośnikami, co oznacza:
  • .* - zero lub więcej dowolnych znaków,
  • param_name= - nazwa param, która jest wyryta,
  • () - grupa w wyrażeniu regularnym,
  • [^&]* - jedna lub więcej dowolnych postaci z wyłączeniem & ,
  • | - przemienność,
  • $1 - odniesienie do pierwszej grupy w wyrażeniu regularnym.

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}'`);

Jeszcze jedna sugestia.

Istnieją już dobre odpowiedzi, ale uznałem je za niepotrzebnie złożone i trudne do zrozumienia. Jest krótki, prosty i zwraca prostą tablicę asocjacyjną z nazwami kluczy odpowiadającymi nazwom tokenów w adresie URL.

Dodałem wersję z komentarzami poniżej dla tych, którzy chcą się uczyć.

Zauważ, że opiera się na jQuery ($ .each) dla swojej pętli, którą polecam zamiast forEach. Uważam, że łatwiej jest zapewnić kompatybilność z różnymi przeglądarkami, używając jQuery w całym systemie, niż podłączać poszczególne poprawki w celu obsługi tych nowych funkcji, które nie są obsługiwane w starszych przeglądarkach.

Edycja: Po tym, jak to napisałem, zauważyłem odpowiedź Erica Elliotta, która jest prawie taka sama, chociaż używa ona dlaEach, podczas gdy ogólnie jestem przeciwny (z powodów wymienionych powyżej).

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;
}

Skomentowana wersja:

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
}

W poniższych przykładach przyjmiemy ten adres:

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

Możesz przypisać tokeny URL do własnej zmiennej:

var tokens = getTokens();

Następnie odwołaj się do każdego tokena URL według nazwy w następujący sposób:

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

Spowoduje to wydrukowanie „4”.

Możesz również po prostu odwołać się bezpośrednio do nazwy tokena z funkcji:

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

... który wydrukowałby „murray”.

// 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"];

Dostał się stąd: http://jquery-howto.blogspot.ru/2009/09/get-url-parameters-values-w--quest.html

Prosta droga

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

następnie nazwij to jak getParams (url)

Musiałem przeczytać zmienną URL GET i wykonać akcję na podstawie parametru url. Szukałem wysokiego i niskiego rozwiązania w celu znalezienia rozwiązania. Zasadniczo odczytuje bieżący adres strony, wykonuje wyrażenie regularne na adresie URL, a następnie zapisuje parametry adresu URL w tablicy asocjacyjnej, do której mamy łatwy dostęp.

Jako przykład, gdybyśmy mieli następujący adres URL z javascript u dołu na miejscu.

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

Wszystko, co musimy zrobić, aby uzyskać parametry id i stronę, to wywołać to:

Kod będzie:

<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"     

Ten Gist autorstwa Eldona McGuinnessa jest zdecydowanie najbardziej kompletną implementacją parsera ciągów zapytań JavaScript, jaki do tej pory widziałem.

Niestety jest napisany jako wtyczka jQuery.

Przepisałem go na waniliowy JS i wprowadziłem kilka ulepszeń:

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"));

Zobacz także to skrzypce .

Eleganckie, funkcjonalne rozwiązanie

Utwórzmy obiekt zawierający nazwy parametrów URL jako klucze, a następnie możemy łatwo wyodrębnić parametr po jego nazwie:

// 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;

Oto co robię:

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;
}