Comment obtenir la valeur des paramètres GET?

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?

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' URLobjet (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);

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

la source

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.

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

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

Eric Bidelman, ingénieur chez Google, recommande d' utiliser ce polyfill pour les navigateurs non pris en charge.

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

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;

J'ai écrit une solution plus simple et élégante.

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

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:

• Est récursif
• Gère plusieurs paramètres du même nom
• Traite bien les chaînes de paramètres mal formées (valeurs manquantes, etc.)
• Ne se casse pas si '=' est dans la valeur
• Effectue le décodage d'URL
• Et enfin, c'est génial parce que ... 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'];

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

Regarde ça

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

j'utilise

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

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

1. Convertir document.location en chaîne (c'est un objet)
2. Alimentez cette chaîne au constructeur de classe URI URI.js
3. Appelez la fonction search () pour obtenir la partie recherche (requête) de l'url
   (passer true lui indique de sortir un objet)
4. Accédez à la propriété foo sur l'objet résultant pour obtenir la valeur

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

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.

La façon la plus simple d'utiliser la replace()méthode:

De la urlStrchaî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&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"     

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