Ich habe eine URL mit einigen GET-Parametern wie folgt:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
Ich muss den ganzen Wert von bekommen c
. Ich habe versucht, die URL zu lesen, aber ich habe nur m2
. Wie mache ich das mit JavaScript?
Ich habe eine URL mit einigen GET-Parametern wie folgt:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
Ich muss den ganzen Wert von bekommen c
. Ich habe versucht, die URL zu lesen, aber ich habe nur m2
. Wie mache ich das mit JavaScript?
Antworten:
In JavaScript selbst ist nichts für die Verarbeitung von Abfragezeichenfolgenparametern integriert.
Code, der in einem (modernen) Browser ausgeführt wird, kann das URL
Objekt verwenden (das Teil der APIs ist, die von Browsern für JS bereitgestellt werden):
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);
Für ältere Browser (einschließlich Internet Explorer) können Sie diese Polyfüllung oder den Code aus der Originalversion dieser Antwort verwenden, die älter ist als URL
:
Sie könnten darauf zugreifen location.search
, was Ihnen von der geben würde?
Zeichen bis zum Ende der URL oder dem Beginn der Fragmentkennung (#foo) erhalten würde, je nachdem, was zuerst eintritt.
Dann können Sie es damit analysieren:
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);
Sie können die Abfragezeichenfolge von der URL der aktuellen Seite abrufen mit:
var query = window.location.search.substring(1);
var qs = parse_query_string(query);
URL
URLSearchParams
. Oder Sie können diesem Problem ausweichen, indem Sie die Zeile var c = url.searchParams.get("c");
in der obigen Antwort durch ersetzen var c = new URLSearchParams(window.location.search).get("c");
.
new URL()
erwartet, eine ordnungsgemäß codierte URL als Argument zu erhalten. decodeURIComponent
erwartet, dass eine Komponente einer URL übergeben wird, nicht eine ganze URL.
decodeURIComponent
sollte in diesem Fall nicht verwendet werden
parse_query_string
Funktion führt eine Doppeldecodierung von durch value
. Das =
von @ManelClos erwähnte Problem kann durch Hinzufügen eines zweiten Parameters 2
( limit
) behoben werden vars[i].split()
.
Die meisten Implementierungen, die ich gesehen habe, haben die URL-Dekodierung der Namen und Werte verpasst.
Hier ist eine allgemeine Dienstprogrammfunktion, die auch die richtige URL-Dekodierung durchführt:
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(' ');
und nicht 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')
Dies ist eine einfache Möglichkeit, nur einen Parameter zu überprüfen:
Beispiel-URL:
http://myserver/action?myParam=2
Beispiel Javascript:
var myParam = location.search.split('myParam=')[1]
Wenn "myParam" in der URL ... -Variable vorhanden ist, enthält myParam "2", andernfalls ist es undefiniert.
Vielleicht möchten Sie in diesem Fall einen Standardwert:
var myParam = location.search.split('myParam=')[1] ? location.search.split('myParam=')[1] : 'myDefaultValue';
Update: Das funktioniert besser:
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';
Und es funktioniert auch dann richtig, wenn die URL voller Parameter ist.
http://myserver/action?myParam=2&anotherParam=3
würde "2"
aber nicht nachgeben "2&anotherParam=3"
.
(location.search.split('myParam=')[1]||'').split('&')[0]
- zur Verwendung mit mehreren Parametern oder möglicherweise fehlenden myParam
.
location.search.split('myParam=').splice(1).join('').split('&')[0]
[?|&]
wie in[?|&]myParam=([^&]+)
result = decodeURIComponent(result);
Browser-Anbieter haben eine native Methode implementiert, um dies über URL und URLSearchParams zu tun.
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"
Wird derzeit in Firefox, Opera, Safari, Chrome und Edge unterstützt. Eine Liste der Browserunterstützung finden Sie hier .
https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams https://developer.mozilla.org/en-US/docs/Web/API/URL/URL
Eric Bidelman, Ingenieur bei Google, empfiehlt die Verwendung dieser Polyfüllung für nicht unterstützte Browser.
new URLSearchParams("www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5").get('a')
Rückkehr null
für mich? (Auf Chrome Stall). b
und c
scheinen gut zu funktionieren.
url.searchParams
stattdessen new URLSearchParams(url.search)
.
Ich fand das vor Ewigkeiten sehr einfach:
function getUrlVars() {
var vars = {};
var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi,
function(m,key,value) {
vars[key] = value;
});
return vars;
}
Dann nenne es so:
var fType = getUrlVars()["type"];
decodeURIComponent()
Wert, da Sie normalerweise damit arbeiten möchten. Verwenden Sie window.location.search
stattdessen window.location.href
, weil Sie nur an den Parametern interessiert sind, nicht an der gesamten URL.
var vars = {}; window.location.search.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; }); return vars;
Sie können die Abfragezeichenfolge eingeben location.search
und dann alles nach dem Fragezeichen aufteilen:
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
produziert {"array[]": "2"}
, was eindeutig falsch ist.
[]
Muster nur in einigen Fällen eine Bedeutung (z. B. PHP), in anderen jedoch nicht. Also nicht "eindeutig falsch" - nur nicht implementiert, um einen nicht standardmäßigen Fall zu behandeln, den Sie möglicherweise behandeln müssen oder nicht.
Ich habe eine einfachere und elegantere Lösung geschrieben.
var arr = document.URL.match(/room=([0-9]+)/)
var room = arr[1];
[0-9]
für\d
Eine super einfache Möglichkeit, URLSearchParams zu verwenden .
function getParam(param){
return new URLSearchParams(window.location.search).get(param);
}
Es wird derzeit in Chrome, Firefox, Safari, Edge und anderen unterstützt .
Hier ist eine rekursive Lösung ohne Regex und mit minimaler Mutation (nur das params-Objekt ist mutiert, was meiner Meinung nach in JS unvermeidbar ist).
Es ist großartig, weil es:
Code:
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'];
Ich habe eine Funktion erstellt, die dies tut:
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;
};
Update 26.05.2017, hier ist eine ES7-Implementierung (läuft mit der voreingestellten Stufe 0, 1, 2 oder 3 von babel):
const getUrlParams = url => `${url}?`.split('?')[1]
.split('&').reduce((params, pair) =>
((key, val) => key ? {...params, [key]: val} : params)
(...`${pair}=`.split('=').map(decodeURIComponent)), {});
Einige Tests:
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 {}
Update 26.03.2008, hier ist eine Typescript-Implementierung:
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
},
{}
)
Update 13.02.2019, hier ist eine aktualisierte TypeScript-Implementierung, die mit TypeScript 3 funktioniert.
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";
}
}
ECMAScript 6-Lösung:
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())
}
ich benutze
function getVal(str) {
var v = window.location.search.match(new RegExp('(?:[\?\&]'+str+'=)([^&]+)'));
return v ? v[1] : null;
}
window.location.search
kein Hash wie #id
.
location.href
, um das Ergebnis anstelle der location.search
.Danke zu vergleichen.
Ich benutze die parseUri Bibliothek. Damit können Sie genau das tun, wonach Sie fragen:
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'
Hier ist meine Lösung. Wie von Andy E bei der Beantwortung dieser Frage empfohlen , ist es nicht gut für die Leistung Ihres Skripts, wenn wiederholt verschiedene Regex-Zeichenfolgen erstellt, Schleifen ausgeführt usw. werden, um nur einen einzigen Wert zu erhalten. Also habe ich mir ein einfacheres Skript ausgedacht, das alle GET-Parameter in einem einzigen Objekt zurückgibt. Sie sollten es nur einmal aufrufen, das Ergebnis einer Variablen zuweisen und dann zu einem späteren Zeitpunkt mit dem entsprechenden Schlüssel einen beliebigen Wert von dieser Variablen abrufen. Beachten Sie, dass es sich auch um die URI-Dekodierung kümmert (z. B.% 20) und + durch ein Leerzeichen ersetzt:
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;
}
Hier sind einige Tests des Skripts, die Sie sehen können:
// 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".
Oder wenn Sie die Verwendung des URI-Parsing-Rads nicht neu erfinden möchten URI.js.
So ermitteln Sie den Wert eines Parameters mit dem Namen foo:
new URI((''+document.location)).search(true).foo
Was das tut ist
Hier ist eine Geige dafür ... http://jsfiddle.net/m6tett01/12/
Verwenden Sie für einen einzelnen Parameterwert wie diesen index.html? Msg = 1 den folgenden Code:
$(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];
}
Verwenden Sie für alle Parameterwerte den folgenden Code:
$(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
}
}
Hier poste ich ein Beispiel. Aber es ist in jQuery. Hoffe, es wird anderen helfen:
<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>
Der kürzeste Weg:
new URL(location.href).searchParams.get("my_key");
new URL(location.href).searchParams.get("my_key")
over bevorzugen, URLSearchParams
da letzteres beim Abrufen des ersten Abfrageparameters einer URL fehlschlägt.
Diese Frage hat zu viele Antworten, also füge ich eine weitere hinzu.
/**
* 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];
}, []);
}
Verwendungszweck:
getURIParameter("id") // returns the last id or null if not present
getURIParameter("id", true) // returns an array of all ids
Dies bewältigt leere Parameter (die Schlüssel sind ohne vorhanden "=value"
), die Offenlegung sowohl einer skalaren als auch einer Array-basierten API zum Abrufen von Werten sowie die ordnungsgemäße Dekodierung von URI-Komponenten.
replace()
Methode:Aus der urlStr
Zeichenfolge:
paramVal = urlStr.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
oder von der aktuellen URL :
paramVal = document.URL.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
Erläuterung:
document.URL
- interface gibt den Dokumentspeicherort (Seiten-URL) als Zeichenfolge zurück.replace()
- Die Methode gibt eine neue Zeichenfolge zurück, bei der einige oder alle Übereinstimmungen eines Musters durch eine Ersetzung ersetzt werden ./.*param_name=([^&]*).*/
- das Muster der regulären Ausdrücke zwischen Schrägstrichen, was bedeutet:
.*
- null oder mehr Zeichen,param_name=
- param Name, der serched ist,()
- Gruppe im regulären Ausdruck,[^&]*
- eines oder mehrere Zeichen mit Ausnahme von &
,|
- Wechsel,$1
- Verweis auf die erste Gruppe im regulären Ausdruck.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}'`);
Noch ein Vorschlag.
Es gibt bereits einige gute Antworten, aber ich fand sie unnötig komplex und schwer zu verstehen. Dies ist kurz, einfach und gibt ein einfaches assoziatives Array mit Schlüsselnamen zurück, die den Token-Namen in der URL entsprechen.
Ich habe unten eine Version mit Kommentaren für diejenigen hinzugefügt, die lernen möchten.
Beachten Sie, dass dies für die Schleife von jQuery ($ .each) abhängt, die ich anstelle von forEach empfehle. Ich finde es einfacher, die Cross-Browser-Kompatibilität mit jQuery auf der ganzen Linie sicherzustellen, als einzelne Fixes einzufügen, um die neuen Funktionen zu unterstützen, die in älteren Browsern nicht unterstützt werden.
Bearbeiten: Nachdem ich dies geschrieben habe, habe ich Eric Elliotts Antwort bemerkt, die fast dieselbe ist, obwohl sie für jeden verwendet wird, während ich generell dagegen bin (aus den oben genannten Gründen).
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;
}
Kommentierte Version:
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
}
Für die folgenden Beispiele nehmen wir diese Adresse an:
http://www.example.com/page.htm?id=4&name=murray
Sie können die URL-Token Ihrer eigenen Variablen zuweisen:
var tokens = getTokens();
Verweisen Sie dann auf jedes URL-Token mit folgendem Namen:
document.write( tokens['id'] );
Dies würde "4" drucken.
Sie können auch einfach direkt auf einen Token-Namen in der Funktion verweisen:
document.write( getTokens()['name'] );
... was "Murray" drucken würde.
// 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"];
Von hier erhalten: http://jquery-howto.blogspot.ru/2009/09/get-url-parameters-values-with-jquery.html
Einfacher Weg
function getParams(url){
var regex = /[?&]([^=#]+)=([^&#]*)/g,
params = {},
match;
while(match = regex.exec(url)) {
params[match[1]] = match[2];
}
return params;
}
dann nenne es wie getParams (url)
Ich musste eine URL-GET-Variable lesen und eine Aktion basierend auf dem URL-Parameter ausführen. Ich suchte hoch und niedrig nach einer Lösung und stieß auf diesen kleinen Code. Es liest im Grunde die aktuelle Seiten-URL, führt einen regulären Ausdruck für die URL aus und speichert dann die URL-Parameter in einem assoziativen Array, auf das wir leicht zugreifen können.
Als Beispiel, wenn wir die folgende URL mit dem Javascript unten hatten.
http://TestServer/Pages/NewsArchive.aspx?year=2013&Month=July
Alles, was wir tun müssen, um die Parameter-ID und die Seite zu erhalten, ist Folgendes aufzurufen:
Der Code lautet:
<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"
Dieser Kern von Eldon McGuinness ist bei weitem die vollständigste Implementierung eines JavaScript-Abfragezeichenfolgen-Parsers, den ich bisher gesehen habe.
Leider ist es als jQuery-Plugin geschrieben.
Ich habe es in Vanilla JS umgeschrieben und einige Verbesserungen vorgenommen:
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"));
Siehe auch diese Geige .
Elegante, funktionale Lösung
Erstellen wir ein Objekt, das URL-Parameternamen als Schlüssel enthält, und extrahieren den Parameter dann einfach anhand seines Namens:
// 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;
Folgendes mache ich:
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;
}