Many of the solutions provided here are inefficient. Repeating the regular expression search each time the script needs to access a parameter is entirely unnecessary. A single function to break down the parameters into an associative-array style object is sufficient. Unless you're utilizing the HTML 5 History API, this process is only required once per page load. Additionally, other suggestions shared in this thread do not correctly decode the URL.

var urlParams;
(window.<a href="https://developer.mozilla.org/en-US/docs/DOM/window.onpopstate" rel="noreferrer">onpopstate</a> = function () {
    var match,
        pl     = /\+/g,  // Regular expression for replacing addition symbol with a space
        search = /([^&=]+)=?([^&]*)/g,
        decode = function (s) { return <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/decodeURIComponent" rel="noreferrer">decodeURIComponent</a>(s.replace(pl, " ")); },
        query  = window.<a href="https://developer.mozilla.org/en-US/docs/DOM/window.location" rel="noreferrer">location</a>.search.<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/substring" rel="noreferrer">substring</a>(1);
  
    urlParams = {};
    while (match = search.<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/exec" rel="noreferrer">exec</a>(query))
       urlParams[decode(match[1])] = decode(match[2]);
})();

For instance, take a look at this querystring:

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

The result would be:

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

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

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

This method can be enhanced to handle array-style query strings as well. You can find an example of this here, although I won't include the source code here due to array-style parameters not being defined in RFC 3986. Interested individuals can refer to campbeln's answer below for a more detailed explanation.

Furthermore, it's worth mentioning that ; can also serve as a legal delimiter for key=value pairs. However, handling both ; and & would require a more complex regex, which may not be necessary given the infrequent usage of ;. In cases where ; needs to be supported instead of &, a simple swap in the regex would suffice.

<script>var urlParams = <?php echo <a href="http://php.net/manual/en/function.json-encode.php" rel="noreferrer">json_encode</a>($_GET, JSON_HEX_TAG);?>;</script>

Simplicity at its best!

#UPDATED

An additional feature would involve retrieving repeated parameters such as myparam=1&myparam=2. While there isn't a specific specification, most existing methods generate an array to accommodate this scenario.

myparam = ["1", "2"]

Here's how you can manage it effectively:

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

    while (match = search.exec(query)) {
        if (decode(match[1]) in urlParams) {
            if (!Array.isArray(urlParams[decode(match[1])])) {
                urlParams[decode(match[1])] = [urlParams[decode(match[1])]];
            }
            urlParams[decode(match[1])].push(decode(match[2]));
        } else {
            urlParams[decode(match[1])] = decode(match[2]);
        }
    }
})();

Welcome to ES2015 (ES6)!

parseQueryString = 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;
                }, {}
            )
        : {}
};

No jQuery Required

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

For an URL like ?topic=123&name=query+string, the following will be returned:

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

Google's Approach

I discovered Google's method: 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
}

Although obfuscated, it is fairly understandable. However, some variables are undefined.

They search for parameters in the URL starting from ? and also from the hash #. For each parameter, they split it at the equal sign b[f][p]("=") (similar to indexOf). Then, they check whether the parameter has a value or not, storing the value of d if present.

The object d is finally returned with escaping and handling the + sign, similar to my implementation.

A Custom Implementation as a jQuery Plugin

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

Usage

//Get a parameter
$.QueryString.param
//-or-
$.QueryString["param"]
//Output: "val"

//Get all parameters as an object
$.QueryString
//Output: Object { param: "val", param2: "val" }

//Set a parameter (only in the $.QueryString object, doesn't affect the browser's querystring)
$.QueryString.param = "newvalue"
//Update the $.QueryString object

//Convert object into a string suitable for a URL querystring (Requires jQuery)
$.param($.QueryString)
//Output: "param=newvalue¶m2=val"

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

Performance Comparison Test (split vs regex methods) (jsPerf)

Preparation code: declaration of methods

Using Split Method

var qs = window.GetQueryString(query);

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

Using Regex Method

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

Test Results on Firefox 4.0 x86 on Windows Server 2008 R2 / 7 x64:

• Split method: 144,780 ±2.17% fastest
• Regex method: 13,891 ±0.85% | 90% slower

URLSearchParams

The latest versions of popular browsers like Firefox, Chrome, Opera, Edge, and Safari now support the URLSearchParams API.

• Chrome Announcement and details
• Opera Announcement and details
• Firefox Announcement and details

If you're using an older version of Internet Explorer, there is a recommended URLSearchParams polyfill available to use.

Although it's not standardized by W3C, the URLSearchParams API follows the living standard set by WhatWG.

You can easily utilize this API on different URLs:

const params = new URLSearchParams(location.search);

or

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

It's also possible to fetch parameters using the shorthand .searchParams property as shown below:

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

You can manipulate parameters with methods such as get(KEY), set(KEY, VALUE), and append(KEY, VALUE). Furthermore, iterating over all values with for (let p of params) {} is supported.

To audit and test, there are a reference implementation and a sample page available.

Enhanced iteration of Artem Barger's response:

function retrieveParameterByName(name) {
    var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
    return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
}

To find out more about the enhancements made, visit:

Here's a great suggestion for you! The plugin Purl can easily fetch different parts of a URL, such as the anchor and host.

You have the option to use Purl with or without jQuery.

The usage of this plugin is quite straightforward and impressive:

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

However, please note that Purl has not been maintained since Nov 11, 2014, and the author suggests using URI.js instead. This alternative focuses on elements and can be used directly as 'URI', with or without jQuery. You can find more detailed documentation here:

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

tl;dr

A concise and efficient solution that manages multiple keys and encoded characters.

// using ES5   (200 characters)
var qd = {};
if (location.search) location.search.substr(1).split("&").forEach(function(item) {var s = item.split("="), k = s[0], v = s[1] && decodeURIComponent(s[1]); (qd[k] = qd[k] || []).push(v)})

// using ES6   (23 characters cooler)
var qd = {};
if (location.search) location.search.substr(1).split`&`.forEach(item => {let [k,v] = item.split`=`; v = v && decodeURIComponent(v); (qd[k] = qd[k] || []).push(v)})

// as a function with reduce
function getQueryParams() {
  return location.search
    ? location.search.substr(1).split`&`.reduce((qd, item) => {let [k,v] = item.split`=`; v = v && decodeURIComponent(v); (qd[k] = qd[k] || []).push(v); return qd}, {})
    : {}
}

Multi-lined:

var qd = {};
if (location.search) location.search.substr(1).split("&").forEach(function(item) {
    var s = item.split("="),
        k = s[0],
        v = s[1] && decodeURIComponent(s[1]); 
    (qd[k] = qd[k] || []).push(v) 
})

This code handles multiple encoding techniques and is optimized for efficiency.
Learn more about "null-coalescing", short-circuit evaluation.
Explore ES6 features like Destructuring assignments, Arrow functions, and Template strings ####Example:

"?a=1&b=0&c=3&d&e&a=5&a=t%20e%20x%20t&e=http%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dståle%26car%3Dsaab"
> qd
a: ["1", "5", "t e x t"]
b: ["0"]
c: ["3"]
d: [undefined]
e: [undefined, "http://w3schools.com/my test.asp?name=ståle&car=saab"]

> qd.a[1]    // "5"
> qd["a"][1] // "5"

Explore the Vanilla JavaScript Solution in Detail.

To manipulate various parts of a URL, leverage location.(search|hash)

Straightforward Approach

var queryDict = {};
location.search.substr(1).split("&").forEach(function(item) {queryDict[item.split("=")[0]] = item.split("=")[1]})

• Correctly manages empty keys.
• Overwrites duplicate keys with the last encountered value.

"?a=1&b=0&c=3&d&e&a=5"
> queryDict
a: "5"
b: "0"
c: "3"
d: undefined
e: undefined

Handling Multiple Values for Keys

Check for existing key and append values accordingly

(item in dict) ? dict.item.push(val) : dict.item = [val]

var qd = {};
location.search.substr(1).split("&").forEach(function(item) {(item.split("=")[0] in qd) ? qd[item.split("=")[0]].push(item.split("=")[1]) : qd[item.split("=")[0]] = [item.split("=")[1]])}

• Returns arrays for each key.
• Access values using qd.key[index] or qd[key][index]

> qd
a: ["1", "5"]
b: ["0"]
c: ["3"]
d: [undefined]
e: [undefined]

Dealing with Encoded Characters

Utilize decodeURIComponent() for proper handling of encoded values within URLs.

var qd = {};
location.search.substr(1).split("&").forEach(function(item) {var k = item.split("=")[0], v = decodeURIComponent(item.split("=")[1]); (k in qd) ? qd[k].push(v) : qd[k] = [v]})

####Example:

"?a=1&b=0&c=3&d&e&a=5&a=t%20e%20x%20t&e=http%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dståle%26car%3Dsaab"
> qd
a: ["1", "5", "t e x t"]
b: ["0"]
c: ["3"]
d: ["undefined"]  
e: ["undefined", "http://w3schools.com/my test.asp?name=ståle&car=saab"]

v = v && decodeURIComponent(v);

if (location.search) location.search.substr(1).split("&").forEach(...)

If you're looking to easily extract parameters from a URL, Roshambo on snipplr.com has a convenient script outlined in Get URL Parameters with jQuery | Improved. His method allows you to effortlessly retrieve the specific parameters you need.

Here is a summary of how it works:

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

You can then fetch your desired parameters from the query string.

For instance, if the URL/query string looked like this: xyz.example/index.html?lang=de.

All you have to do is use

var langval = $.urlParam('lang');

UZBEKJON also discusses this topic in a detailed blog post, Get URL parameters & values with jQuery.

For those utilizing jQuery, an option is to integrate a library like jQuery BBQ: Back Button & Query Library.

...jQuery BBQ comes with a comprehensive .deparam() method, as well as functionalities for hash state management, and fragment / query string parsing and merging.

Edit: Example of Using Deparam:

 var DeparamExample = function() {
            var params = $.deparam.querystring();

            //nameofparam is the name of a param from url
            //code below will get param if ajax refresh with hash
            if (typeof params.nameofparam == 'undefined') {
                params = jQuery.deparam.fragment(window.location.href);
            }
            
            if (typeof params.nameofparam != 'undefined') {
                var paramValue = params.nameofparam.toString();
                  
            }
        };

If you prefer using plain JavaScript, an alternative could be...

var getParamValue = (function() {
    var params;
    var resetParams = function() {
            var query = window.location.search;
            var regex = /[?&;](.+?)=([^&;]+)/g;
            var match;

            params = {};

            if (query) {
                while (match = regex.exec(query)) {
                    params[match[1]] = decodeURIComponent(match[2]);
                }
            }    
        };

    window.addEventListener
    && window.addEventListener('popstate', resetParams);

    resetParams();

    return function(param) {
        return params.hasOwnProperty(param) ? params[param] : null;
    }

})();​

With the introduction of the HTML History API and specifically history.pushState() and history.replaceState(), changes in the URL can occur which may render the cache of parameters and their values outdated.

This version will consistently update its internal parameter cache whenever there are history changes.

Using two splits can solve the problem efficiently:

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

After reviewing various answers, it seems that this is the simplest and quickest method. You can verify its speed on this jsPerf benchmark.

If you encounter Rup's scenario, you can make a slight adjustment by adding a conditional split as shown below in order to ensure accuracy. However, please note that this slightly reduces the performance compared to using regex (refer to jsPerf).

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

If your situation does not involve Rup's specific scenario, then this solution is ideal. Otherwise, consider utilizing regex.

Alternatively, if you have control over the querystring and can guarantee that the value being obtained will never contain any URL encoded characters (which should be avoided), you can use the following simplified and more understandable version of the first option:

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

Presenting a jQuery plugin based on Andy E's solution:

;(function ($) {
    $.extend({      
        retrieveParameter: function (paramName) {           
            function extractParams() {
                var parameters = {},
                    temp,
                    space = /\+/g,  // Regular expression for replacing addition symbol with a space
                    regex = /([^&=]+)=?([^&]*)/g,
                    decode = function (s) { return decodeURIComponent(s.replace(space, " ")); },
                    query = window.location.search.substring(1);

                while (temp = regex.exec(query))
                    parameters[decode(temp[1])] = decode(temp[2]);

                return parameters;
            }

            if (!this.paramsFromQueryString)
                this.paramsFromQueryString = extractParams(); 

            return this.paramsFromQueryString[paramName];
        }
    });
})(jQuery);

Usage example:

var myVariable = $.retrieveParameter('desiredParam');

A convenient blend of functionality and ease!

If you find yourself in need of more advanced URL manipulation beyond just parsing the querystring, check out URI.js. This library is designed for effectively handling URLs and comes equipped with a full range of features. (Apologies for the self-promotion)

Here's how you can transform your querystring into a map:

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

(Additionally, URI.js corrects faulty querystrings like ?&foo&&bar=baz& to ?foo&bar=baz)

I appreciate the solution provided by Ryan Phelan, however, I question the necessity of extending jQuery in this scenario as there is no utilization of jQuery functionality.

Contrastingly, I find the built-in function in Google Chrome, window.location.getParameter, to be appealing.

Considering that other browsers may not have this functionality, why not implement it ourselves if it's missing:

if (!window.location.getParameter ) {
  window.location.getParameter = function(key) {
    function parseParams() {
        var params = {},
            e,
            a = /\+/g,  // Regex for replacing addition symbol with a space
            r = /([^&=]+)=?([^&]*)/g,
            d = function (s) { return decodeURIComponent(s.replace(a, " ")); },
            q = window.location.search.substring(1);

        while (e = r.exec(q))
            params[d(e[1])] = d(e[2]);

        return params;
    }

    if (!this.queryStringParams)
        this.queryStringParams = parseParams(); 

    return this.queryStringParams[key];
  };
}

This implementation shares similarities with Ryan Phelan's approach, but it stands out with a distinct name and no reliance on other JavaScript libraries. Read more about this function on my blog.

Need a quick solution for retrieving an object similar to PHP's $_GET array?

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

How to use:

var $_GET = retrieveQueryParams();

With the query string x=5&y&z=hello&x=6, you will get this object:

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

Simplify your JavaScript with this clean code:

function retrieveQuery(key) {
    var variables = [], hashValue;
    var hashesArray = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
    for(var index = 0; index < hashesArray.length; index++)
    {
        hashValue = hashesArray[index].split('=');
        variables.push(hashValue[0]);
        variables[hashValue[0]] = hashValue[1];
    }
    return variables[key];
}

Easily utilize it in your JavaScript project:

var output = retrieveQuery('specificKey');

According to MDN:

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

alert(retrieveValue("category"));

After exploring various solutions, I decided to create a more comprehensive method that I believe you will find useful.

This library includes a simple method for dissecting and manipulating URL parameters. The static method consists of several sub-methods that can be invoked on the given URL:

• getHost
• getPath
• getHash
• setHash
• getParams
• getQuery
• setParam
• getParam
• hasParam
• removeParam

For example:

URLParser(url).getParam('myparam1')

var url = "http://www.example.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>');

Shortening code:

let params = location.search && location.search.substr(1).replace(/\+/gi," ").split("&");
for (let param in params) {
    let pair = params[param].split("=");
    params[param]  = params[unescape(pair[0])] = unescape(pair[1]);
}

Display the results:

for (let key in params) {
    document.write(key + ":" + params[key] + "<br/>");   
};

Output on my PC:

test.htm?i=can&has=cheesecake

0:can
1:cheesecake
i:can
has:cheesecake

While I do frequently use regular expressions, they are not my go-to for this particular task.

I find it more practical and efficient to parse the query string once within my application and construct an object containing all the key/value pairs like so:

var retrieveQueryParams = function() {
  var queryString = window.location.search.substr(1),
    params = queryString.split(/\&/), length = params.length, keyValuePair, result = {};
  if (length === 0) {return false;}
  while (length--) {
    keyValuePair = params[length].split(/\=/);
    result[keyValuePair[0]] = decodeURIComponent(keyValuePair[1] || '') || true;
  }
  return result;
}();

As a result, with a URL such as

http://example.com?param1=val1&param2=val2

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


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

Roshambo jQuery method was not handling URL decoding properly

Incorporated the decoding functionality into the return statement for better performance

return decodeURIComponent(results[1].replace(/\+/g, " ")) || 0;

The updated gist can now be accessed:

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

Here is a revision I made to this fantastic response, now equipped with the ability to parse query strings containing keys but no values.

var url = 'http://sb.com/reg/step1?param';
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[1]) p[1] = decodeURIComponent(p[1].replace(/\+/g, " "));
        b[p[0]] = p[1];
    }
    return b;
})((url.split('?'))[1].split('&'));

NOTE! The function's parameter in the last line has been altered. This serves as an illustration of how any URL can be passed to it. To parse the current URL, you can utilize the last line from Bruno's solution.

So what exactly was modified? When using the URL http://sb.com/reg/step1?param=, the results remain unchanged. However, when using the URL http://sb.com/reg/step1?param, Bruno's approach outputs an object without keys, while mine produces an object with a key param and a value of undefined.

Here's a helpful script I found on this website:

// retrieve an array containing all querystring values
// example: var value = getUrlVars()["value"];
function getUrlVars() {
    var variables = [], 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('=');
        variables.push(hash[0]);
        variables[hash[0]] = hash[1];
    }
    return variables;
}

This code works perfectly for my needs.

Presented here is an enhanced version of Andy E's reference to handling array-style query strings. Numerous improvements have been made, including bug fixes (such as addressing the issue where `1` is replaced with `[2,3]` in `?key=1&key[]=2&key[]=3`), performance enhancements, and additional features like support for different delimiters and handling edge cases. Despite using short variable names, extensive comments are provided for clarity.

The functionality illustrated below is based on a sample query string:

?test=Hello&person=neek&person[]=jeff&person[]=jim&person[extra]=john&test3&nocache=1398914891264

Once processed, the resulting object representation looks like this:

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

This version can handle scenarios involving "malformed" arrays, such as `person=neek&person[]=jeff&person[]=jim` or `person=neek&person=jeff&person=jim`, by identifying valid keys according to specifications.

The core code snippets are outlined below:

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


getQueryStringAsObject = function() {
    // Code block for processing the query string
};

When I was in need of extracting an object from the query string, I wanted a solution that didn't involve writing tons of code. While it may not be the most foolproof method out there, the few lines of code below get the job done.

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

For example, if the URL is like this.htm?hello=world&foo=bar, the result will be:

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

This function was crafted by me some time ago and I am quite satisfied with its performance. One of its key features is that it is not case sensitive, which adds convenience. Additionally, if the requested query string does not exist, it simply returns an empty string.

I usually utilize a compressed version of this code. However, I'm sharing the uncompressed version here to provide a clearer explanation for beginners.

While there may be ways to optimize or modify this function for faster execution, it has consistently met my requirements effectively.

Feel free to make use of it.

function getQSP(sName, sURL) {
    var theItmToRtn = "";
    var theSrchStrg = location.search;
    if (sURL) theSrchStrg = sURL;
    var sOrig = theSrchStrg;
    theSrchStrg = theSrchStrg.toUpperCase();
    sName = sName.toUpperCase();
    theSrchStrg = theSrchStrg.replace("?", "&") theSrchStrg = theSrchStrg + "&";
    var theSrchToken = "&" + sName + "=";
    if (theSrchStrg.indexOf(theSrchToken) != -1) {
        var theSrchTokenLth = theSrchToken.length;
        var theSrchTokenLocStart = theSrchStrg.indexOf(theSrchToken) + theSrchTokenLth;
        var theLocOfNextAndSign = theSrchStrg.indexOf("&", theSrchTokenLocStart);
        theItmToRtn = unescape(sOrig.substring(theSrchTokenLocStart, theLocOfNextAndSign));
    }
    return unescape(theItmToRtn);
}

function RetrieveParameters(parameter)
{
    var pageURL = window.location.search.substring(1);
    var URLVariables = pageURL.split('&');

    for (var j = 0; j < URLVariables.length; j++)
    {
        var parameterName = URLVariables[j].split('=');
        if (parameterName[0] == parameter)
        {
            return parameterName[1];
        }
    }
}​

This is how you can utilize the function with a given URL:

http://example.com/?text=javascript&word=programming

var term1 = RetrieveParameters('text');
var term2 = RetrieveParameters('word');

If you utilize Browserify, the url module from Node.js can be helpful:

var url = require('url');

url.parse('http://example.com/?bob=123', true).query;

// returns { "bob": "123" }

For more information, check out: URL Node.js v0.12.2 Manual & Documentation

UPDATE: The URL interface is gaining popularity and is widely supported in most modern browsers. In case of older browser compatibility issues, a polyfill like this one can be used. Here's an example code snippet demonstrating how to use the URL interface to extract query parameters:

const url = new URL('http://example.com/?bob=123');
url.searchParams.get('bob'); 

Another method is using URLSearchParams, here's an example from MDN on how to do it with URLSearchParams:

var paramsString = "q=URLUtils.searchParams&topic=api";
var searchParams = new URLSearchParams(paramsString);

//Iterate the search parameters.
for (let p of searchParams) {
  console.log(p);
}

searchParams.has("topic") === true; // true
searchParams.get("topic") === "api"; // true
searchParams.getAll("topic"); // ["api"]
searchParams.get("foo") === null; // true
searchParams.append("topic", "webdev");
searchParams.toString(); // "q=URLUtils.searchParams&topic=api&topic=webdev"
searchParams.set("topic", "More webdev");
searchParams.toString(); // "q=URLUtils.searchParams&topic=More+webdev"
searchParams.delete("topic");
searchParams.toString(); // "q=URLUtils.searchParams"

We are excited to announce the launch of our latest project, arg.js. Our goal with this project is to finally provide a solution to a problem that has historically been quite challenging. With arg.js, you can now easily achieve:

var name = Arg.get("name");

Or retrieve all parameters like this:

var params = Arg.all();

If you are interested in distinguishing between ?query=true and #hash=true, you can utilize the Arg.query() and Arg.hash() methods.

The issue with the highest-rated response to that query is the placement of unsupported parameters after the hash symbol, which can sometimes be necessary to retrieve the desired value.

To address this, I have updated the code to enable parsing of a complete query string including the hash sign:

var fetchQueryData = function(key) {
    var output = null;
    var pattern = "[\\?&#]" + key + "=([^&#]*)";
    var regexPattern = new RegExp(pattern);
    var dataMatches = regexPattern.exec('?' + window.location.href.split('?')[1]);
    if (dataMatches !== null) {
        output = decodeURIComponent(dataMatches[1].replace(/\+/g, " "));
    }
    return output;
};