una - passare parametri url javascript




Come posso ottenere valori stringa di query in JavaScript? (20)

Esiste un modo senza plugin per recuperare i valori della stringa di query tramite jQuery (o senza)?

Se é cosi, come? Se no, c'è un plugin che può farlo?


ES2015 (ES6)

getQueryStringParams = query => {
    return query
        ? (/^[?#]/.test(query) ? query.slice(1) : query)
            .split('&')
            .reduce((params, param) => {
                    let [key, value] = param.split('=');
                    params[key] = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';
                    return params;
                }, {}
            )
        : {}
};

Senza jQuery

var qs = (function(a) {
    if (a == "") return {};
    var b = {};
    for (var i = 0; i < a.length; ++i)
    {
        var p=a[i].split('=', 2);
        if (p.length == 1)
            b[p[0]] = "";
        else
            b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
    }
    return b;
})(window.location.search.substr(1).split('&'));

Con un URL come ?topic=123&name=query+string , verrà restituito il seguente:

qs["topic"];    // 123
qs["name"];     // query string
qs["nothere"];  // undefined (object)

Metodo di Google

Strappando il codice di Google ho trovato il metodo che usano: getUrlParameters

function (b) {
    var c = typeof b === "undefined";
    if (a !== h && c) return a;
    for (var d = {}, b = b || k[B][vb], e = b[p]("?"), f = b[p]("#"), b = (f === -1 ? b[Ya](e + 1) : [b[Ya](e + 1, f - e - 1), "&", b[Ya](f + 1)][K](""))[z]("&"), e = i.dd ? ia : unescape, f = 0, g = b[w]; f < g; ++f) {
        var l = b[f][p]("=");
        if (l !== -1) {
            var q = b[f][I](0, l),
                l = b[f][I](l + 1),
                l = l[Ca](/\+/g, " ");
            try {
                d[q] = e(l)
            } catch (A) {}
        }
    }
    c && (a = d);
    return d
}

È offuscato, ma è comprensibile.

Iniziano a cercare i parametri nell'url da ? e anche dall'hash # . Quindi per ogni parametro si dividono nel segno di uguale b[f][p]("=") (che assomiglia a indexOf , usano la posizione del char per ottenere la chiave / il valore). Dopo averlo diviso, controllano se il parametro ha un valore o meno, se ha quindi memorizzato il valore di d , altrimenti continuano semplicemente.

Alla fine viene restituito l'oggetto d , gestendo l'escape e il segno + . Questo oggetto è uguale al mio, ha lo stesso comportamento.

Il mio metodo come plugin jQuery

(function($) {
    $.QueryString = (function(paramsArray) {
        let params = {};

        for (let i = 0; i < paramsArray.length; ++i)
        {
            let param = paramsArray[i]
                .split('=', 2);

            if (param.length !== 2)
                continue;

            params[param[0]] = decodeURIComponent(param[1].replace(/\+/g, " "));
        }

        return params;
    })(window.location.search.substr(1).split('&'))
})(jQuery);

uso

//Get a param
$.QueryString.param
//-or-
$.QueryString["param"]
//This outputs something like...
//"val"

//Get all params as object
$.QueryString
//This outputs something like...
//Object { param: "val", param2: "val" }

//Set a param (only in the $.QueryString object, doesn't affect the browser's querystring)
$.QueryString.param = "newvalue"
//This doesn't output anything, it just updates the $.QueryString object

//Convert object into string suitable for url a querystring (Requires jQuery)
$.param($.QueryString)
//This outputs something like...
//"param=newvalue&param2=val"

//Update the url/querystring in the browser's location bar with the $.QueryString object
history.replaceState({}, '', "?" + $.param($.QueryString));
//-or-
history.pushState({}, '', "?" + $.param($.QueryString));

Test delle prestazioni (metodo split rispetto al metodo regex) ( jsPerf )

Codice di preparazione: dichiarazione dei metodi

Split test code

var qs = window.GetQueryString(query);

var search = qs["q"];
var value = qs["value"];
var undef = qs["undefinedstring"];

Codice di prova Regex

var search = window.getParameterByName("q");
var value = window.getParameterByName("value");
var undef = window.getParameterByName("undefinedstring");

Test su Firefox 4.0 x86 su Windows Server 2008 R2 / 7 x64

  • Metodo split : 144.780 ± 2,17% più veloce
  • Metodo Regex : 13,891 ± 0,85% | 90% più lento

URLSearchParams

Firefox 44+, Opera 36+, Edge 17+, Safari 10.3+ e Chrome 49+ supportano l'API URLSearchParams :

Esiste un polyfill URLSearchParams suggerito da google per le versioni stabili di IE.

Non è standardizzato dal W3C , ma è uno standard di vita di WhatWG .

Puoi usarlo sul posto, ma devi rimuovere il ? punto interrogativo (ad esempio, con .slice(1) ):

let params = new URLSearchParams(location.search);

o

let params = (new URL(location)).searchParams;

O ovviamente su qualsiasi URL:

let url = new URL('https://example.com?foo=1&bar=2');
let params = new URLSearchParams(url.search);

Puoi ottenere parametri usando anche una proprietà .searchParams sull'oggetto URL, in questo modo:

let params = new URL('https://example.com?foo=1&bar=2').searchParams;
params.get('foo'); // "1"
params.get('bar'); // "2" 

Si leggono / impostano i parametri tramite l'API get(KEY) , set(KEY, VALUE) , append(KEY, VALUE) . Puoi anche eseguire iterazioni su tutti i valori for (let p of params) {} .

Un'implementazione di riferimento e una pagina di esempio sono disponibili per il controllo e il test.


Alcune delle soluzioni pubblicate qui sono inefficienti. La ripetizione della ricerca di espressioni regolari ogni volta che lo script deve accedere a un parametro è completamente inutile, una sola funzione per dividere i parametri in un oggetto di stile array associativo è sufficiente. Se non stai lavorando con l'HTML 5 History API, questo è necessario solo una volta per caricamento della pagina. Anche qui gli altri suggerimenti non riescono a decodificare correttamente l'URL.

var urlParams;
(window.onpopstate = function () {
    var match,
        pl     = /\+/g,  // Regex for replacing addition symbol with a space
        search = /([^&=]+)=?([^&]*)/g,
        decode = function (s) { return decodeURIComponent(s.replace(pl, " ")); },
        query  = window.location.search.substring(1);

    urlParams = {};
    while (match = search.exec(query))
       urlParams[decode(match[1])] = decode(match[2]);
})();

Esempio querystring:

?i=main&mode=front&sid=de8d49b78a85a322c4155015fdce22c4&enc=+Hello%20&empty

Risultato:

 urlParams = {
    enc: " Hello ",
    i: "main",
    mode: "front",
    sid: "de8d49b78a85a322c4155015fdce22c4",
    empty: ""
}

alert(urlParams["mode"]);
// -> "front"

alert("empty" in urlParams);
// -> true

Questo potrebbe facilmente essere migliorato per gestire anche le stringhe di query in stile array. Un esempio di questo è here , ma poiché i parametri dello stile di matrice non sono definiti in RFC 3986 non voglio inquinare questa risposta con il codice sorgente. Per chi è interessato a una versione "inquinata", guarda sotto la risposta di Campbeln .

Inoltre, come sottolineato nei commenti ; è un delimitatore legale per coppie key=value . Richiederebbe una regex più complessa da gestire ; o & , che penso non sia necessario perché è raro che ; è usato e direi ancora più improbabile che entrambi vengano usati. Se hai bisogno di supporto ; invece di & , basta scambiarli nella regex.

Se stai usando un linguaggio di pre-elaborazione lato server, potresti voler usare le sue funzioni JSON native per fare il lavoro più impegnativo. Ad esempio, in PHP puoi scrivere:

<script>var urlParams = <?php echo json_encode($_GET, JSON_HEX_TAG);?>;</script>

Molto più semplice!


Basta usare due split :

function get(n) {
    var half = location.search.split(n + '=')[1];
    return half !== undefined ? decodeURIComponent(half.split('&')[0]) : null;
}

Stavo leggendo tutte le risposte precedenti e più complete. Ma penso che sia il metodo più semplice e veloce. Puoi controllare questo benchmark jsPerf

Per risolvere il problema nel commento di Rup, aggiungi una divisione condizionale modificando la prima riga con i due seguenti. Ma la precisione assoluta significa che ora è più lento di regexp (vedi jsPerf ).

function get(n) {
    var half = location.search.split('&' + n + '=')[1];
    if (!half) half = location.search.split('?' + n + '=')[1];
    return half !== undefined ? decodeURIComponent(half.split('&')[0]) : null;
}

Quindi se sai che non incontrerai la contro-cassa di Rup, questo vince. Altrimenti, regexp.

O se hai il controllo della querystring e puoi garantire che un valore che stai cercando di ottenere non conterrà mai caratteri codificati URL (avere questi in un valore sarebbe una cattiva idea) - puoi usare la seguente versione leggermente più semplificata e leggibile della prima opzione:

    function getQueryStringValueByName(name) {
        var queryStringFromStartOfValue = location.search.split(name + '=')[1];
         return queryStringFromStartOfValue !== undefined ? queryStringFromStartOfValue.split('&')[0] : null;

Ecco un modo veloce per ottenere un oggetto simile all'array $_GET PHP:

function get_query(){
    var url = location.search;
    var qs = url.substring(url.indexOf('?') + 1).split('&');
    for(var i = 0, result = {}; i < qs.length; i++){
        qs[i] = qs[i].split('=');
        result[qs[i][0]] = decodeURIComponent(qs[i][1]);
    }
    return result;
}

Uso:

var $_GET = get_query();

Per la stringa di query x=5&y&z=hello&x=6 questo restituisce l'oggetto:

{
  x: "6",
  y: undefined,
  z: "hello"
}

Mantieni tutto in un semplice codice JavaScript:

function qs(key) {
    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[key];
}

Chiamalo da qualsiasi parte nel codice JavaScript:

var result = qs('someKey');

Queste sono tutte ottime risposte, ma avevo bisogno di qualcosa di un po 'più robusto, e ho pensato che tutti potreste voler avere ciò che ho creato.

È un semplice metodo di libreria che esegue la dissezione e la manipolazione dei parametri URL. Il metodo statico ha i seguenti metodi secondari che possono essere richiamati nell'URL dell'oggetto:

  • getHost
  • getPath
  • gethash
  • setHash
  • getparams
  • getQuery
  • SetParam
  • getParam
  • hasParam
  • RemoveParam

Esempio:

URLParser(url).getParam('myparam1')
var url = "http://www.test.com/folder/mypage.html?myparam1=1&myparam2=2#something";

function URLParser(u){
    var path="",query="",hash="",params;
    if(u.indexOf("#") > 0){
        hash = u.substr(u.indexOf("#") + 1);
        u = u.substr(0 , u.indexOf("#"));
    }
    if(u.indexOf("?") > 0){
        path = u.substr(0 , u.indexOf("?"));
        query = u.substr(u.indexOf("?") + 1);
        params= query.split('&');
    }else
        path = u;
    return {
        getHost: function(){
            var hostexp = /\/\/([\w.-]*)/;
            var match = hostexp.exec(path);
            if (match != null && match.length > 1)
                return match[1];
            return "";
        },
        getPath: function(){
            var pathexp = /\/\/[\w.-]*(?:\/([^?]*))/;
            var match = pathexp.exec(path);
            if (match != null && match.length > 1)
                return match[1];
            return "";
        },
        getHash: function(){
            return hash;
        },
        getParams: function(){
            return params
        },
        getQuery: function(){
            return query;
        },
        setHash: function(value){
            if(query.length > 0)
                query = "?" + query;
            if(value.length > 0)
                query = query + "#" + value;
            return path + query;
        },
        setParam: function(name, value){
            if(!params){
                params= new Array();
            }
            params.push(name + '=' + value);
            for (var i = 0; i < params.length; i++) {
                if(query.length > 0)
                    query += "&";
                query += params[i];
            }
            if(query.length > 0)
                query = "?" + query;
            if(hash.length > 0)
                query = query + "#" + hash;
            return path + query;
        },
        getParam: function(name){
            if(params){
                for (var i = 0; i < params.length; i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) == name)
                        return decodeURIComponent(pair[1]);
                }
            }
            console.log('Query variable %s not found', name);
        },
        hasParam: function(name){
            if(params){
                for (var i = 0; i < params.length; i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) == name)
                        return true;
                }
            }
            console.log('Query variable %s not found', name);
        },
        removeParam: function(name){
            query = "";
            if(params){
                var newparams = new Array();
                for (var i = 0;i < params.length;i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) != name)
                          newparams .push(params[i]);
                }
                params = newparams;
                for (var i = 0; i < params.length; i++) {
                    if(query.length > 0)
                        query += "&";
                    query += params[i];
                }
            }
            if(query.length > 0)
                query = "?" + query;
            if(hash.length > 0)
                query = query + "#" + hash;
            return path + query;
        },
    }
}


document.write("Host: " + URLParser(url).getHost() + '<br>');
document.write("Path: " + URLParser(url).getPath() + '<br>');
document.write("Query: " + URLParser(url).getQuery() + '<br>');
document.write("Hash: " + URLParser(url).getHash() + '<br>');
document.write("Params Array: " + URLParser(url).getParams() + '<br>');
document.write("Param: " + URLParser(url).getParam('myparam1') + '<br>');
document.write("Has Param: " + URLParser(url).hasParam('myparam1') + '<br>');

document.write(url + '<br>');

// Remove the first parameter
url = URLParser(url).removeParam('myparam1');
document.write(url + ' - Remove the first parameter<br>');

// Add a third parameter
url = URLParser(url).setParam('myparam3',3);
document.write(url + ' - Add a third parameter<br>');

// Remove the second parameter
url = URLParser(url).removeParam('myparam2');
document.write(url + ' - Remove the second parameter<br>');

// Add a hash
url = URLParser(url).setHash('newhash');
document.write(url + ' - Set Hash<br>');

// Remove the last parameter
url = URLParser(url).removeParam('myparam3');
document.write(url + ' - Remove the last parameter<br>');

// Remove a parameter that doesn't exist
url = URLParser(url).removeParam('myparam3');
document.write(url + ' - Remove a parameter that doesn\"t exist<br>');

Roshambo su snipplr.com ha uno script semplice per ottenere ciò descritto in Ottieni parametri URL con jQuery | Migliorato Con la sua sceneggiatura puoi anche facilmente estrarre solo i parametri che desideri.

Ecco il succo:

$.urlParam = function(name, url) {
    if (!url) {
     url = window.location.href;
    }
    var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(url);
    if (!results) { 
        return undefined;
    }
    return results[1] || undefined;
}

Quindi recupera i parametri dalla stringa di query.

Quindi, se la stringa URL / query era xyz.com/index.html?lang=de .

Basta chiamare var langval = $.urlParam('lang'); e ce l'hai

UZBEKJON ha anche un ottimo post sul blog, Ottieni parametri e valori URL con jQuery .


Se stai facendo più manipolazioni di URL che semplicemente analizzando la QueryString, potresti trovare utile URI.js È una libreria per manipolare gli URL e viene fornito con tutti i campanelli e i fischietti. (Ci scusiamo per l'auto-pubblicità qui)

per convertire la tua querystring in una mappa:

var data = URI('?foo=bar&bar=baz&foo=world').query(true);
data == {
  "foo": ["bar", "world"],
  "bar": "baz"
}

(URI.js inoltre "ripara" le stringhe difettose come ?&foo&&bar=baz& a ?foo&bar=baz )


Solo un'altra raccomandazione Il plugin Purl consente di recuperare tutte le parti dell'URL, inclusi anchor, host, ecc.

Può essere utilizzato con o senza jQuery.

L'utilizzo è molto semplice e interessante:

var url = $.url('http://allmarkedup.com/folder/dir/index.html?item=value'); // jQuery version
var url = purl('http://allmarkedup.com/folder/dir/index.html?item=value'); // plain JS version
url.attr('protocol'); // returns 'http'
url.attr('path'); // returns '/folder/dir/index.html'

Tuttavia, a partire dall'11 novembre 2014, Purl non viene più mantenuto e l'autore consiglia invece di utilizzare URI.js Il plugin jQuery è diverso in quanto si concentra sugli elementi - per l'utilizzo con le stringhe, basta usare direttamente l' URI , con o senza jQuery. Il codice simile apparirebbe come tale, documenti più completi here :

var url = new URI('http://allmarkedup.com/folder/dir/index.html?item=value'); // plain JS version
url.protocol(); // returns 'http'
url.path(); // returns '/folder/dir/index.html'

Aggiornamento: settembre 2018

Puoi utilizzare URLSearchParams che è semplice e ha un buon supporto per i browser .

const urlParams = new URLSearchParams(window.location.search);
const myParam = urlParams.get('myParam');

orignal

Non hai bisogno di jQuery per questo scopo. Puoi usare solo un puro JavaScript:

function getParameterByName(name, url) {
    if (!url) url = window.location.href;
    name = name.replace(/[\[\]]/g, '\\$&');
    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
        results = regex.exec(url);
    if (!results) return null;
    if (!results[2]) return '';
    return decodeURIComponent(results[2].replace(/\+/g, ' '));
}

Uso:

// query string: ?foo=lorem&bar=&baz
var foo = getParameterByName('foo'); // "lorem"
var bar = getParameterByName('bar'); // "" (present with empty value)
var baz = getParameterByName('baz'); // "" (present with no value)
var qux = getParameterByName('qux'); // null (absent)


Nota: se un parametro è presente più volte ( ?foo=lorem&foo=ipsum ), otterrai il primo valore ( lorem ). Non esiste uno standard su questo e gli usi variano, vedi ad esempio questa domanda: Posizione autorevole delle chiavi di query HTTP GET duplicate .
NOTA: la funzione fa distinzione tra maiuscole e minuscole. Se si preferisce il nome del parametro senza distinzione tra maiuscole e minuscole, aggiungere il modificatore "i" a RegExp

Questo è un aggiornamento basato sulle nuove specifiche di URLSearchParams per ottenere lo stesso risultato in modo più sintetico. Vedere la risposta intitolata " URLSearchParams " di seguito.


Codice golf:

var a = location.search&&location.search.substr(1).replace(/\+/gi," ").split("&");
for (var i in a) {
    var s = a[i].split("=");
    a[i]  = a[unescape(s[0])] = unescape(s[1]);
}

Visualizzalo!

for (i in a) {
    document.write(i + ":" + a[i] + "<br/>");   
};

Sul mio Mac: test.htm?i=can&has=cheezburgerdisplay

0:can
1:cheezburger
i:can
has:cheezburger

Il problema con la risposta più alta a questa domanda è che i parametri non supportati vengono posizionati dopo #, ma a volte è necessario ottenere anche questo valore.

Ho modificato la risposta per consentire di analizzare una stringa di query completa con un segno di hash anche:

var getQueryStringData = function(name) {
    var result = null;
    var regexS = "[\\?&#]" + name + "=([^&#]*)";
    var regex = new RegExp(regexS);
    var results = regex.exec('?' + window.location.href.split('?')[1]);
    if (results != null) {
        result = decodeURIComponent(results[1].replace(/\+/g, " "));
    }
    return result;
};

Uso molto le espressioni regolari, ma non per questo.

Mi sembra più semplice e più efficiente leggere la stringa di query una volta nella mia applicazione e creare un oggetto da tutte le coppie chiave / valore come:

var search = function() {
  var s = window.location.search.substr(1),
    p = s.split(/\&/), l = p.length, kv, r = {};
  if (l === 0) {return false;}
  while (l--) {
    kv = p[l].split(/\=/);
    r[kv[0]] = decodeURIComponent(kv[1] || '') || true;
  }
  return r;
}();

Per un URL come http://domain.com?param1=val1&param2=val2te puoi ottenere il loro valore più tardi nel tuo codice come search.param1e search.param2.


Avevo bisogno di un oggetto dalla stringa di query e odio molto codice. Potrebbe non essere il più robusto dell'universo, ma solo poche righe di codice.

var q = {};
location.href.split('?')[1].split('&').forEach(function(i){
    q[i.split('=')[0]]=i.split('=')[1];
});

Un URL simile this.htm?hello=world&foo=barcreerà:

{hello:'world', foo:'bar'}

Dal MDN :

function loadPageVar (sVar) {
  return unescape(window.location.search.replace(new RegExp("^(?:.*[&\\?]" + escape(sVar).replace(/[\.\+\*]/g, "\\$&") + "(?:\\=([^&]*))?)?.*$", "i"), "$1"));
}

alert(loadPageVar("name"));

Ecco una versione estesa della versione "Gestisci serie di stringhe di query stile array" di Andy E. Risolto un bug ( ?key=1&key[]=2&key[]=3; 1viene perso e sostituito con [2,3]), apportato alcuni miglioramenti minori delle prestazioni (ri-decodifica dei valori, ricalcolo della posizione "[", ecc.) E aggiunto una serie di miglioramenti (supporto funzionalizzato, supporto per ?key=1&key=2, ;delimitatori) . Ho lasciato le variabili fastidiosamente brevi, ma ho aggiunto commenti a bizzeffe per renderle leggibili (oh, e ho riutilizzato vle funzioni locali, scusa se ciò è fonte di confusione;).

Gestirà il seguente querystring ...

? Test = Ciao & persona = neek & persona [] = Jeff & persona [] = Jim & persona [extra] = John & test3 & nocache = 1.398.914,891264 millions

... trasformandolo in un oggetto che sembra ...

{
    "test": "Hello",
    "person": {
        "0": "neek",
        "1": "jeff",
        "2": "jim",
        "length": 3,
        "extra": "john"
    },
    "test3": "",
    "nocache": "1398914891264"
}

Come si può vedere sopra, questa versione gestisce alcune misure di matrici "malformate", ovvero - person=neek&person[]=jeff&person[]=jimo person=neek&person=jeff&person=jimcome la chiave è identificabile e valida (almeno in dotNet's NameValueCollection.Add ):

Se la chiave specificata esiste già nell'istanza NameValueCollection di destinazione, il valore specificato viene aggiunto all'elenco di valori di valori separati da virgole nella forma "valore1, valore2, valore3".

Sembra che la giuria sia in qualche modo fuori dai tasti ripetuti in quanto non ci sono specifiche. In questo caso, più chiavi vengono memorizzate come una matrice (falsa). Ma tieni presente che non elaboro i valori in base alle virgole negli array.

Il codice:

getQueryStringKey = function(key) {
    return getQueryStringAsObject()[key];
};


getQueryStringAsObject = function() {
    var b, cv, e, k, ma, sk, v, r = {},
        d = function (v) { return decodeURIComponent(v).replace(/\+/g, " "); }, //# d(ecode) the v(alue)
        q = window.location.search.substring(1), //# suggested: q = decodeURIComponent(window.location.search.substring(1)),
        s = /([^&;=]+)=?([^&;]*)/g //# original regex that does not allow for ; as a delimiter:   /([^&=]+)=?([^&]*)/g
    ;

    //# ma(make array) out of the v(alue)
    ma = function(v) {
        //# If the passed v(alue) hasn't been setup as an object
        if (typeof v != "object") {
            //# Grab the cv(current value) then setup the v(alue) as an object
            cv = v;
            v = {};
            v.length = 0;

            //# If there was a cv(current value), .push it into the new v(alue)'s array
            //#     NOTE: This may or may not be 100% logical to do... but it's better than loosing the original value
            if (cv) { Array.prototype.push.call(v, cv); }
        }
        return v;
    };

    //# While we still have key-value e(ntries) from the q(uerystring) via the s(earch regex)...
    while (e = s.exec(q)) { //# while((e = s.exec(q)) !== null) {
        //# Collect the open b(racket) location (if any) then set the d(ecoded) v(alue) from the above split key-value e(ntry) 
        b = e[1].indexOf("[");
        v = d(e[2]);

        //# As long as this is NOT a hash[]-style key-value e(ntry)
        if (b < 0) { //# b == "-1"
            //# d(ecode) the simple k(ey)
            k = d(e[1]);

            //# If the k(ey) already exists
            if (r[k]) {
                //# ma(make array) out of the k(ey) then .push the v(alue) into the k(ey)'s array in the r(eturn value)
                r[k] = ma(r[k]);
                Array.prototype.push.call(r[k], v);
            }
            //# Else this is a new k(ey), so just add the k(ey)/v(alue) into the r(eturn value)
            else {
                r[k] = v;
            }
        }
        //# Else we've got ourselves a hash[]-style key-value e(ntry) 
        else {
            //# Collect the d(ecoded) k(ey) and the d(ecoded) sk(sub-key) based on the b(racket) locations
            k = d(e[1].slice(0, b));
            sk = d(e[1].slice(b + 1, e[1].indexOf("]", b)));

            //# ma(make array) out of the k(ey) 
            r[k] = ma(r[k]);

            //# If we have a sk(sub-key), plug the v(alue) into it
            if (sk) { r[k][sk] = v; }
            //# Else .push the v(alue) into the k(ey)'s array
            else { Array.prototype.push.call(r[k], v); }
        }
    }

    //# Return the r(eturn value)
    return r;
};

Mi piace questo (tratto da jquery-howto.blogspot.co.uk):

// get an array with all querystring values
// example: var valor = getUrlVars()["valor"];
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;
}

Funziona alla grande per me.


function GET() {
        var data = [];
        for(x = 0; x < arguments.length; ++x)
            data.push(location.href.match(new RegExp("/\?".concat(arguments[x],"=","([^\n&]*)")))[1])
                return data;
    }


example:
data = GET("id","name","foo");
query string : ?id=3&name=jet&foo=b
returns:
    data[0] // 3
    data[1] // jet
    data[2] // b
or
    alert(GET("id")[0]) // return 3

function GetQueryStringParams(sParam)
{
    var sPageURL = window.location.search.substring(1);
    var sURLVariables = sPageURL.split('&');

    for (var i = 0; i < sURLVariables.length; i++)
    {
        var sParameterName = sURLVariables[i].split('=');
        if (sParameterName[0] == sParam)
        {
            return sParameterName[1];
        }
    }
}​

E questo è come puoi usare questa funzione presumendo che l'URL sia

http://dummy.com/?stringtext=jquery&stringword=jquerybyexample

var tech = GetQueryStringParams('stringtext');
var blog = GetQueryStringParams('stringword');






query-string