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?
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?
Odpowiedzi:
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ć URL
obiektu (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);
URL
oprócz tego dla URLSearchParams
. Możesz też uniknąć tego problemu, zastępując wiersz var c = url.searchParams.get("c");
w powyższej odpowiedzi słowem var c = new URLSearchParams(window.location.search).get("c");
.
new URL()
oczekuje, że otrzyma poprawnie zakodowany adres URL jako argument. decodeURIComponent
oczekuje, że zostanie przekazany składnik adresu URL, a nie cały adres URL.
decodeURIComponent
nie należy stosować w tym przypadku
parse_query_string
Funkcja robi podwójnego dekodowania value
. =
Wydane wymienić @ManelClos można rozwiązać przez dodanie drugiego parametru 2
( limit
) do vars[i].split()
.
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);
qs.split('+').join(' ');
nie qs.replace(/\+/g, ' ');
?
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.
http://myserver/action?myParam=2&anotherParam=3
dałby nie, "2"
ale "2&anotherParam=3"
.
(location.search.split('myParam=')[1]||'').split('&')[0]
- do użycia z wieloma parametrami lub ewentualnie brakującymi myParam
.
location.search.split('myParam=').splice(1).join('').split('&')[0]
[?|&]
jak w[?|&]myParam=([^&]+)
result = decodeURIComponent(result);
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
Eric Bidelman, inżynier z Google, zaleca stosowanie tego wypełnienia w nieobsługiwanych przeglądarkach.
new URLSearchParams("www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5").get('a')
wraca null
? (W stabilnym Chrome). b
i c
wydaje się, że działa dobrze.
url.searchParams
zamiast tego new URLSearchParams(url.search)
.
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"];
decodeURIComponent()
na wartości, ponieważ z tym zwykle chcesz pracować; użyj window.location.search
zamiast window.location.href
, ponieważ interesują Cię tylko parametry, a nie cały adres URL.
var vars = {}; window.location.search.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; }); return vars;
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;
?array[]=1&array[]=2
Produkuje {"array[]": "2"}
, co jest wyraźnie błędne.
[]
wzorzec ma znaczenie tylko w niektórych przypadkach (np. PHP), ale nie w innych. Więc nie „wyraźnie źle” - po prostu nie został zaimplementowany do obsługi niestandardowych przypadków, które możesz, ale nie musisz, obsługiwać.
Napisałem prostsze i eleganckie rozwiązanie.
var arr = document.URL.match(/room=([0-9]+)/)
var room = arr[1];
[0-9]
na\d
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ż:
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, {})
Object {"": ""}
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())
function urlParams(url) { const [, searchParams = ''] = url.split('?') return searchParams.split('&') .map(v => v.split('=')) .reduce((map, [key = '', value]) => key.length ? map.set(key, decodeURIComponent(value)) : map, new Map())
}
używam
function getVal(str) {
var v = window.location.search.match(new RegExp('(?:[\?\&]'+str+'=)([^&]+)'));
return v ? v[1] : null;
}
window.location.search
nie będzie zawierać skrótu #id
.
location.href
który pasuje do wyniku zamiastlocation.search
.Dziękuję.
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
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");
new URL(location.href).searchParams.get("my_key")
ponad, URLSearchParams
ponieważ to drugie zakończy się niepowodzeniem podczas pobierania pierwszego parametru zapytania z dowolnego adresu URL.
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.
replace()
metody:Z urlStr
cią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¶m_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;
}