Wie erhalte ich den Wert aus den GET-Parametern?

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?

In JavaScript selbst ist nichts für die Verarbeitung von Abfragezeichenfolgenparametern integriert.

Code, der in einem (modernen) Browser ausgeführt wird, kann das URLObjekt 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);

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

Quelle

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.

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

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

Eric Bidelman, Ingenieur bei Google, empfiehlt die Verwendung dieser Polyfüllung für nicht unterstützte Browser.

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

Sie können die Abfragezeichenfolge eingeben location.searchund 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;

Ich habe eine einfachere und elegantere Lösung geschrieben.

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

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:

• Ist rekursiv
• Behandelt mehrere gleichnamige Parameter
• Kann gut mit fehlerhaften Parameterzeichenfolgen umgehen (fehlende Werte usw.)
• Bricht nicht, wenn '=' im Wert ist
• Führt eine URL-Dekodierung durch
• Und schließlich ist es großartig, weil es ... argh !!!

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

Sieh dir das an

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

ich benutze

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

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

1. Konvertieren Sie document.location in eine Zeichenfolge (es ist ein Objekt).
2. Führen Sie diese Zeichenfolge dem URI-Klassenkonstrutor von URI.js zu
3. Rufen Sie die Funktion search () auf, um den Suchabschnitt (Abfrage) der URL abzurufen
   (die Übergabe von true weist sie an, ein Objekt auszugeben).
4. Greifen Sie auf die foo-Eigenschaft des resultierenden Objekts zu, um den Wert abzurufen

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

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.

Der einfachste Weg mit der replace()Methode:

Aus der urlStrZeichenfolge:

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

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