Ho un URL con alcuni parametri GET come segue:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
Ho bisogno di ottenere l'intero valore di c
. Ho provato a leggere l'URL, ma ho ottenuto solo m2
. Come posso fare questo usando JavaScript?
Ho un URL con alcuni parametri GET come segue:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
Ho bisogno di ottenere l'intero valore di c
. Ho provato a leggere l'URL, ma ho ottenuto solo m2
. Come posso fare questo usando JavaScript?
Risposte:
JavaScript stesso non ha nulla incorporato per la gestione dei parametri della stringa di query.
Codice in esecuzione in un browser (moderno) è possibile utilizzare l' URL
oggetto (che fa parte delle API fornite dai browser a 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);
Per i browser meno recenti (incluso Internet Explorer), è possibile utilizzare questo polyfill o il codice dalla versione originale di questa risposta che precede URL
:
Potresti accedere location.search
, che ti darebbe dal ?
personaggio alla fine dell'URL o all'inizio dell'identificatore di frammento (#foo), a seconda di quale evento si verifichi per primo.
Quindi puoi analizzarlo con questo:
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);
Puoi ottenere la stringa di query dall'URL della pagina corrente con:
var query = window.location.search.substring(1);
var qs = parse_query_string(query);
URL
in aggiunta a quello per URLSearchParams
. Oppure puoi evitare questo problema sostituendo la riga var c = url.searchParams.get("c");
nella risposta sopra con var c = new URLSearchParams(window.location.search).get("c");
.
new URL()
prevede di ricevere un URL codificato correttamente come argomento. decodeURIComponent
prevede di passare un componente di un URL, non un intero URL.
decodeURIComponent
non dovrebbe essere usato in questo caso
parse_query_string
funzione esegue una doppia decodifica di value
. L' =
emissione menzionata da @ManelClos può essere indirizzata aggiungendo un secondo parametro 2
( limit
) a vars[i].split()
.
Molte implementazioni che ho visto mancano la decodifica URL dei nomi e dei valori.
Ecco una funzione di utilità generale che esegue anche la decodifica URL corretta:
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(' ');
e no 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')
Questo è un modo semplice per controllare solo un parametro:
URL di esempio:
http://myserver/action?myParam=2
Esempio Javascript:
var myParam = location.search.split('myParam=')[1]
se "myParam" esiste nell'URL ... la variabile myParam conterrà "2", altrimenti non sarà definita.
Forse vuoi un valore predefinito, in quel caso:
var myParam = location.search.split('myParam=')[1] ? location.search.split('myParam=')[1] : 'myDefaultValue';
Aggiornamento: funziona meglio:
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';
E funziona bene anche quando l'URL è pieno di parametri.
http://myserver/action?myParam=2&anotherParam=3
non cederebbe "2"
ma "2&anotherParam=3"
.
(location.search.split('myParam=')[1]||'').split('&')[0]
- da utilizzare con più parametri o eventualmente mancante myParam
.
location.search.split('myParam=').splice(1).join('').split('&')[0]
[?|&]
come in[?|&]myParam=([^&]+)
result = decodeURIComponent(result);
I fornitori di browser hanno implementato un modo nativo per farlo tramite URL e 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"
Attualmente supportato in Firefox, Opera, Safari, Chrome ed Edge. Per un elenco del supporto del browser, vedere qui .
https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams https://developer.mozilla.org/en-US/docs/Web/API/URL/URL
Eric Bidelman, un ingegnere di Google, consiglia di utilizzare questo polyfill per browser non supportati.
new URLSearchParams("www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5").get('a')
tornando null
per me? (Su Chrome stabile). b
e c
sembra funzionare bene.
url.searchParams
invece new URLSearchParams(url.search)
.
L'ho trovato secoli fa, molto semplice:
function getUrlVars() {
var vars = {};
var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi,
function(m,key,value) {
vars[key] = value;
});
return vars;
}
Quindi chiamalo così:
var fType = getUrlVars()["type"];
decodeURIComponent()
il valore, perché è quello con cui di solito vuoi lavorare; usa window.location.search
invece di window.location.href
, perché sei interessato solo ai parametri, non all'intero URL.
var vars = {}; window.location.search.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; }); return vars;
È possibile ottenere la stringa di query location.search
, quindi è possibile dividere tutto dopo il punto interrogativo:
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
produce {"array[]": "2"}
, il che è chiaramente sbagliato.
[]
modello ha un significato solo in alcuni casi (ad esempio PHP), ma non in altri. Quindi non "chiaramente sbagliato" - semplicemente non implementato per gestire un caso non standard che potrebbe essere necessario o meno necessario gestire.
Ho scritto una soluzione più semplice ed elegante.
var arr = document.URL.match(/room=([0-9]+)/)
var room = arr[1];
[0-9]
per\d
Un modo semplicissimo con URLSearchParams .
function getParam(param){
return new URLSearchParams(window.location.search).get(param);
}
Attualmente è supportato in Chrome, Firefox, Safari, Edge e altri .
Ecco una soluzione ricorsiva che non ha regex e ha una mutazione minima (solo l'oggetto params è mutato, che credo sia inevitabile in JS).
È fantastico perché:
Codice:
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'];
Ho creato una funzione che fa questo:
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;
};
Aggiornamento 26/05/2017, ecco un'implementazione di ES7 (funziona con lo stadio 0, 1, 2 o 3 preimpostato di babele):
const getUrlParams = url => `${url}?`.split('?')[1]
.split('&').reduce((params, pair) =>
((key, val) => key ? {...params, [key]: val} : params)
(...`${pair}=`.split('=').map(decodeURIComponent)), {});
Alcuni test:
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 {}
Aggiornamento 26/03/2018, ecco un'implementazione di Typescript:
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
},
{}
)
Aggiornamento 13/02/2019, ecco un'implementazione TypeScript aggiornata che funziona con 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";
}
}
Soluzione 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())
}
Io uso
function getVal(str) {
var v = window.location.search.match(new RegExp('(?:[\?\&]'+str+'=)([^&]+)'));
return v ? v[1] : null;
}
window.location.search
non includerà l'hash like #id
.
location.href
corrisponde al risultato anziché al location.search
. Grazie.
Uso la libreria parseUri . Ti permette di fare esattamente quello che stai chiedendo:
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'
Ecco la mia soluzione Come consigliato da Andy E mentre risponde a questa domanda , non è buono per l'esecuzione del tuo script se sta ripetutamente costruendo varie stringhe regex, eseguendo loop ecc. Solo per ottenere un singolo valore. Quindi, ho escogitato uno script più semplice che restituisce tutti i parametri GET in un singolo oggetto. Dovresti chiamarlo solo una volta, assegnare il risultato a una variabile e quindi, in qualsiasi momento in futuro, ottenere qualsiasi valore desiderato da quella variabile usando la chiave appropriata. Nota che si occupa anche della decodifica URI (ad esempio cose come% 20) e sostituisce + con uno spazio:
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;
}
Quindi, ecco alcuni test dello script che puoi vedere:
// 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".
O se non si desidera reinventare la ruota di analisi URI, utilizzare URI.js
Per ottenere il valore di un parametro chiamato foo:
new URI((''+document.location)).search(true).foo
Quello che fa è
Ecco un violino per questo .... http://jsfiddle.net/m6tett01/12/
Per un valore di parametro singolo come questo index.html? Msg = 1 usa il seguente codice,
$(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];
}
Per tutti i valori dei parametri utilizzare il codice seguente,
$(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
}
}
Qui sto postando un esempio. Ma è in jQuery. Spero che possa aiutare gli altri:
<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>
Il modo più breve:
new URL(location.href).searchParams.get("my_key");
new URL(location.href).searchParams.get("my_key")
oltre URLSearchParams
poiché quest'ultimo non riuscirà durante il recupero del primo parametro di query di qualsiasi URL.
questa domanda ha troppe risposte, quindi ne sto aggiungendo un'altra.
/**
* 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];
}, []);
}
utilizzo:
getURIParameter("id") // returns the last id or null if not present
getURIParameter("id", true) // returns an array of all ids
ciò consente di gestire parametri vuoti (senza le chiavi presenti "=value"
), l'esposizione di un'API per il recupero di valore scalare e basata su array, nonché la corretta decodifica dei componenti URI.
replace()
metodo:Dalla urlStr
stringa:
paramVal = urlStr.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
o dall'URL corrente :
paramVal = document.URL.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
Spiegazione:
document.URL
- interfaccia restituisce la posizione del documento (URL della pagina) come stringa.replace()
- Il metodo restituisce una nuova stringa con alcune o tutte le corrispondenze di un modello sostituite da una sostituzione ./.*param_name=([^&]*).*/
- il modello di espressione regolare racchiuso tra barre che significa:
.*
- zero o più di qualsiasi carattere,param_name=
- nome param che viene visualizzato,()
- gruppo in espressione regolare,[^&]*
- uno o più caratteri esclusi &
,|
- alternanza,$1
- riferimento al primo gruppo in espressioni regolari.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}'`);
Ancora un altro suggerimento.
Ci sono già alcune buone risposte, ma le ho trovate inutilmente complesse e difficili da capire. È breve, semplice e restituisce un semplice array associativo con nomi di chiave corrispondenti ai nomi di token nell'URL.
Ho aggiunto una versione con commenti qui sotto per coloro che vogliono imparare.
Nota che questo si basa su jQuery ($ .each) per il suo loop, che consiglio invece di forEach. Trovo più semplice garantire la compatibilità cross-browser usando jQuery su tutta la linea piuttosto che collegare singole correzioni per supportare qualunque nuova funzione non sia supportata nei browser più vecchi.
Modifica: Dopo aver scritto questo ho notato la risposta di Eric Elliott, che è quasi la stessa, sebbene utilizzi per Ognuno, mentre in genere sono contrario (per i motivi sopra indicati).
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;
}
Versione commentata:
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
}
Per gli esempi seguenti assumeremo questo indirizzo:
http://www.example.com/page.htm?id=4&name=murray
Puoi assegnare i token URL alla tua variabile:
var tokens = getTokens();
Quindi fai riferimento a ciascun token URL per nome in questo modo:
document.write( tokens['id'] );
Ciò stamperebbe "4".
Puoi anche semplicemente fare riferimento a un nome token direttamente dalla funzione:
document.write( getTokens()['name'] );
... che stampa "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"];
Tratto da qui: http://jquery-howto.blogspot.ru/2009/09/get-url-parameters-values-with-jquery.html
Modo semplice
function getParams(url){
var regex = /[?&]([^=#]+)=([^&#]*)/g,
params = {},
match;
while(match = regex.exec(url)) {
params[match[1]] = match[2];
}
return params;
}
quindi chiamalo come getParams (url)
Ho avuto la necessità di leggere una variabile GET URL e completare un'azione basata sul parametro url. Ho cercato una soluzione in alto e in basso e ho trovato questo piccolo pezzo di codice. Fondamentalmente legge l'URL della pagina corrente, esegue alcune espressioni regolari sull'URL, quindi salva i parametri dell'URL in un array associativo, a cui possiamo facilmente accedere.
Quindi, ad esempio, se avessimo il seguente URL con il javascript in basso sul posto.
http://TestServer/Pages/NewsArchive.aspx?year=2013&Month=July
Tutto ciò che dovremmo fare per ottenere i parametri id e page è chiamare questo:
Il codice sarà:
<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"
This Gist di Eldon McGuinness è di gran lunga l'implementazione più completa di un parser di stringhe di query JavaScript che ho visto finora.
Sfortunatamente, è scritto come un plugin jQuery.
L'ho riscritto su Vanilla JS e ho apportato alcuni miglioramenti:
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"));
Vedi anche questo violino .
Soluzione di stile elegante e funzionale
Creiamo un oggetto contenente i nomi dei parametri URL come chiavi, quindi possiamo facilmente estrarre il parametro con il suo nome:
// 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;
Ecco cosa faccio:
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;
}