J'ai une URL avec certains paramètres GET comme suit:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
J'ai besoin d'obtenir la valeur totale de c
. J'ai essayé de lire l'URL, mais je n'ai obtenu que m2
. Comment faire cela en utilisant JavaScript?
J'ai une URL avec certains paramètres GET comme suit:
www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5
J'ai besoin d'obtenir la valeur totale de c
. J'ai essayé de lire l'URL, mais je n'ai obtenu que m2
. Comment faire cela en utilisant JavaScript?
Réponses:
JavaScript lui-même n'a rien intégré pour gérer les paramètres de chaîne de requête.
Code fonctionnant dans un navigateur (moderne), vous pouvez utiliser l' URL
objet (qui fait partie des API fournies par les navigateurs à 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);
Pour les navigateurs plus anciens (y compris Internet Explorer), vous pouvez utiliser ce polyfill ou le code de la version originale de cette réponse antérieure à URL
:
Vous pouvez y accéder location.search
, ce qui vous donnerait du ?
caractère à la fin de l'URL ou au début de l'identificateur de fragment (#foo), selon la première éventualité.
Ensuite, vous pouvez l'analyser avec ceci:
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);
Vous pouvez obtenir la chaîne de requête à partir de l'URL de la page actuelle avec:
var query = window.location.search.substring(1);
var qs = parse_query_string(query);
URL
en plus de celui pour URLSearchParams
. Ou vous pouvez esquiver ce problème en remplaçant la ligne var c = url.searchParams.get("c");
de la réponse ci-dessus par var c = new URLSearchParams(window.location.search).get("c");
.
new URL()
s'attend à recevoir une URL correctement codée comme argument. decodeURIComponent
s'attend à recevoir un composant d'une URL, pas une URL entière.
decodeURIComponent
ne devrait pas être utilisé dans ce cas
parse_query_string
fonction effectue un double décodage de value
. Le =
problème mentionné par @ManelClos peut être résolu en ajoutant un second paramètre 2
( limit
) à vars[i].split()
.
La plupart des implémentations que j'ai vues manquent le décodage d'URL des noms et des valeurs.
Voici une fonction d'utilité générale qui effectue également le décodage d'URL approprié:
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(' ');
et non 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')
C'est un moyen simple de vérifier un seul paramètre:
Exemple d'URL:
http://myserver/action?myParam=2
Exemple Javascript:
var myParam = location.search.split('myParam=')[1]
si "myParam" existe dans l'URL ... la variable myParam contiendra "2", sinon elle ne sera pas définie.
Vous souhaitez peut-être une valeur par défaut, dans ce cas:
var myParam = location.search.split('myParam=')[1] ? location.search.split('myParam=')[1] : 'myDefaultValue';
Mise à jour: cela fonctionne mieux:
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';
Et cela fonctionne bien même lorsque l'URL est pleine de paramètres.
http://myserver/action?myParam=2&anotherParam=3
ne donnerait pas "2"
mais "2&anotherParam=3"
.
(location.search.split('myParam=')[1]||'').split('&')[0]
- à utiliser avec plusieurs paramètres ou possibliy manquant myParam
.
location.search.split('myParam=').splice(1).join('').split('&')[0]
[?|&]
comme dans[?|&]myParam=([^&]+)
result = decodeURIComponent(result);
Les fournisseurs de navigateurs ont mis en œuvre une manière native de le faire via URL et 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"
Actuellement pris en charge dans Firefox, Opera, Safari, Chrome et Edge. Pour une liste de prise en charge du navigateur, voir ici .
https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams https://developer.mozilla.org/en-US/docs/Web/API/URL/URL
Eric Bidelman, ingénieur chez Google, recommande d' utiliser ce polyfill pour les navigateurs non pris en charge.
new URLSearchParams("www.test.com/t.html?a=1&b=3&c=m2-m3-m4-m5").get('a')
revient null
pour moi? (Sur Chrome stable). b
et c
semblent bien fonctionner.
url.searchParams
plutôt new URLSearchParams(url.search)
.
J'ai trouvé cela il y a très longtemps, très facile:
function getUrlVars() {
var vars = {};
var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi,
function(m,key,value) {
vars[key] = value;
});
return vars;
}
Ensuite, appelez-le comme ceci:
var fType = getUrlVars()["type"];
decodeURIComponent()
sur la valeur, car c'est ce avec quoi vous voulez habituellement travailler; utilisez window.location.search
plutôt window.location.href
, car vous ne vous intéressez qu'aux paramètres, pas à l'url entière.
var vars = {}; window.location.search.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; }); return vars;
Vous pouvez obtenir la chaîne de requête location.search
, puis vous pouvez tout fractionner après le point d'interrogation:
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
produit {"array[]": "2"}
, ce qui est clairement faux.
[]
modèle n'a de sens que dans certains cas (par exemple, PHP), mais pas dans d'autres. Donc, pas "clairement faux" - tout simplement pas implémenté pour gérer un cas non standard que vous pourriez ou non avoir besoin de gérer.
J'ai écrit une solution plus simple et élégante.
var arr = document.URL.match(/room=([0-9]+)/)
var room = arr[1];
[0-9]
pour\d
Une manière super simple d'utiliser URLSearchParams .
function getParam(param){
return new URLSearchParams(window.location.search).get(param);
}
Il est actuellement pris en charge dans Chrome, Firefox, Safari, Edge et autres .
Voici une solution récursive qui n'a pas de regex et a une mutation minimale (seul l'objet params est muté, ce qui, je pense, est inévitable dans JS).
C'est génial parce que:
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'];
J'ai créé une fonction qui fait ceci:
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;
};
Mise à jour 5/26/2017, voici une implémentation ES7 (s'exécute avec babel preset stage 0, 1, 2 ou 3):
const getUrlParams = url => `${url}?`.split('?')[1]
.split('&').reduce((params, pair) =>
((key, val) => key ? {...params, [key]: val} : params)
(...`${pair}=`.split('=').map(decodeURIComponent)), {});
Quelques 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 {}
Mise à jour 26/03/2018, voici une implémentation de Typographie:
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
},
{}
)
Mise à jour du 13/02/2019, voici une implémentation mise à jour de TypeScript qui fonctionne avec 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";
}
}
Solution 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())
}
j'utilise
function getVal(str) {
var v = window.location.search.match(new RegExp('(?:[\?\&]'+str+'=)([^&]+)'));
return v ? v[1] : null;
}
window.location.search
pas de hachage comme #id
.
location.href
pour faire correspondre le résultat au lieu du location.search
.Merci.
J'utilise la bibliothèque parseUri . Il vous permet de faire exactement ce que vous demandez:
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'
Voici ma solution. Comme conseillé par Andy E en répondant à cette question , ce n'est pas bon pour les performances de votre script s'il construit à plusieurs reprises différentes chaînes d'expression régulière, exécute des boucles, etc. juste pour obtenir une valeur unique. Donc, j'ai trouvé un script plus simple qui renvoie tous les paramètres GET dans un seul objet. Vous ne devez l'appeler qu'une seule fois, affecter le résultat à une variable puis, à tout moment dans le futur, obtenir la valeur souhaitée de cette variable à l'aide de la clé appropriée. Notez qu'il prend également en charge le décodage URI (c'est-à-dire des choses comme% 20) et remplace + par un espace:
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;
}
Voici donc quelques tests du script à voir:
// 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".
Ou si vous ne voulez pas réinventer la roue d'analyse d'URI, utilisez URI.js
Pour obtenir la valeur d'un paramètre nommé foo:
new URI((''+document.location)).search(true).foo
Qu'est-ce que cela fait
Voici un violon pour cela .... http://jsfiddle.net/m6tett01/12/
Pour une valeur de paramètre unique comme celle-ci, index.html? Msg = 1, utilisez le code suivant,
$(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];
}
Pour toutes les valeurs de paramètre, utilisez le code suivant,
$(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
}
}
Ici, je poste un exemple. Mais c'est dans jQuery. J'espère que cela aidera les autres:
<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>
Le chemin le plus court:
new URL(location.href).searchParams.get("my_key");
new URL(location.href).searchParams.get("my_key")
over URLSearchParams
car ce dernier échouera lors de la récupération du premier paramètre de requête d'une URL.
cette question a trop de réponses, donc j'en ajoute une autre.
/**
* 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];
}, []);
}
usage:
getURIParameter("id") // returns the last id or null if not present
getURIParameter("id", true) // returns an array of all ids
cela permet de gérer les paramètres vides (les clés présentes sans "=value"
), l'exposition à la fois d'une API de récupération de valeurs scalaire et basée sur un tableau, ainsi que le décodage des composants URI appropriés.
replace()
méthode:De la urlStr
chaîne:
paramVal = urlStr.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
ou à partir de l' URL actuelle :
paramVal = document.URL.replace(/.*param_name=([^&]*).*|(.*)/, '$1');
Explication:
document.URL
- l'interface renvoie l'emplacement du document (URL de la page) sous forme de chaîne.replace()
- La méthode renvoie une nouvelle chaîne avec certaines ou toutes les correspondances d'un modèle remplacées par un remplacement ./.*param_name=([^&]*).*/
- le modèle d' expression régulière entouré de barres obliques, ce qui signifie:
.*
- zéro ou plusieurs caractères,param_name=
- nom du param qui est desséché,()
- groupe en expression régulière,[^&]*
- un ou plusieurs caractères quelconques à l'exclusion &
,|
- alternance,$1
- référence au premier groupe dans l'expression régulière.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}'`);
Encore une autre suggestion.
Il y a déjà de bonnes réponses, mais je les ai trouvées inutilement complexes et difficiles à comprendre. C'est court, simple et renvoie un tableau associatif simple avec des noms de clé correspondant aux noms de jeton dans l'URL.
J'ai ajouté une version avec des commentaires ci-dessous pour ceux qui veulent apprendre.
Notez que cela repose sur jQuery ($ .each) pour sa boucle, que je recommande au lieu de forEach. Je trouve plus simple de garantir la compatibilité entre les navigateurs en utilisant jQuery sur toute la ligne plutôt que de brancher des correctifs individuels pour prendre en charge les nouvelles fonctions qui ne sont pas prises en charge dans les anciens navigateurs.
Edit: Après avoir écrit cela, j'ai remarqué la réponse d'Eric Elliott, qui est presque la même, bien qu'elle utilise forEach, alors que je suis généralement contre (pour les raisons énoncées ci-dessus).
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;
}
Version commentée:
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
}
Pour les exemples ci-dessous, nous supposerons cette adresse:
http://www.example.com/page.htm?id=4&name=murray
Vous pouvez attribuer les jetons URL à votre propre variable:
var tokens = getTokens();
Référez-vous ensuite à chaque jeton d'URL par nom comme ceci:
document.write( tokens['id'] );
Cela afficherait "4".
Vous pouvez également simplement vous référer directement à un nom de jeton à partir de la fonction:
document.write( getTokens()['name'] );
... qui imprimerait "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"];
A partir d'ici: http://jquery-howto.blogspot.ru/2009/09/get-url-parameters-values-with-jquery.html
Manière simple
function getParams(url){
var regex = /[?&]([^=#]+)=([^&#]*)/g,
params = {},
match;
while(match = regex.exec(url)) {
params[match[1]] = match[2];
}
return params;
}
puis appelez-le comme getParams (url)
J'avais besoin de lire une variable URL GET et de terminer une action basée sur le paramètre url. J'ai cherché haut et bas une solution et suis tombé sur ce petit morceau de code. Il lit essentiellement l'URL de la page actuelle, effectue une expression régulière sur l'URL puis enregistre les paramètres d'URL dans un tableau associatif, auquel nous pouvons facilement accéder.
Donc, à titre d'exemple, si nous avions l'URL suivante avec le javascript en bas en place.
http://TestServer/Pages/NewsArchive.aspx?year=2013&Month=July
Tout ce que nous aurions besoin de faire pour obtenir l'ID et la page des paramètres est d'appeler ceci:
Le code sera:
<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"
Ce Gist par Eldon McGuinness est de loin l'implémentation la plus complète d'un analyseur de chaînes de requête JavaScript que j'ai vue jusqu'à présent.
Malheureusement, il est écrit en tant que plugin jQuery.
Je l'ai réécrit sur vanilla JS et j'ai apporté quelques améliorations:
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"));
Voir aussi ce violon .
Solution de style élégante et fonctionnelle
Créons un objet contenant des noms de paramètres d'URL sous forme de clés, puis nous pouvons facilement extraire le paramètre par son nom:
// 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;
Voici ce que je fais:
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;
}