How do i query a parameter in javascript?

Update: Jan-2022

Using Proxy[] is faster than using Object.fromEntries[] and better supported

const params = new Proxy[new URLSearchParams[window.location.search], {
  get: [searchParams, prop] => searchParams.get[prop],
}];
// Get the value of "some_key" in eg "//example.com/?some_key=some_value"
let value = params.some_key; // "some_value"

Update: June-2021

For a specific case when you need all query params:

const urlSearchParams = new URLSearchParams[window.location.search];
const params = Object.fromEntries[urlSearchParams.entries[]];

Update: Sep-2018

You can use URLSearchParams which is simple and has decent [but not complete] browser support.

const urlParams = new URLSearchParams[window.location.search];
const myParam = urlParams.get['myParam'];

Original

You don't need jQuery for that purpose. You can use just some pure JavaScript:

function getParameterByName[name, 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, ' ']];
}

Usage:

// 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]

NOTE: If a parameter is present several times [?foo=lorem&foo=ipsum], you will get the first value [lorem]. There is no standard about this and usages vary, see for example this question: Authoritative position of duplicate HTTP GET query keys.

NOTE: The function is case-sensitive. If you prefer case-insensitive parameter name, add 'i' modifier to RegExp

NOTE: If you're getting a no-useless-escape eslint error, you can replace name = name.replace[/[\[\]]/g, '\\$&']; with name = name.replace[/[[\]]/g, '\\$&'].

This is an update based on the new URLSearchParams specs to achieve the same result more succinctly. See answer titled "URLSearchParams" below.

Some of the solutions posted here are inefficient. Repeating the regular expression search every time the script needs to access a parameter is completely unnecessary, one single function to split up the parameters into an associative-array style object is enough. If you're not working with the HTML 5 History API, this is only necessary once per page load. The other suggestions here also fail to decode the URL correctly.

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

Example querystring:

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

Result:

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

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

alert["empty" in urlParams];
// -> true

This could easily be improved upon to handle array-style query strings too. An example of this is here, but since array-style parameters aren't defined in RFC 3986 I won't pollute this answer with the source code. For those interested in a "polluted" version, look at campbeln's answer below.

Also, as pointed out in the comments, ; is a legal delimiter for key=value pairs. It would require a more complicated regex to handle ; or &, which I think is unnecessary because it's rare that ; is used and I would say even more unlikely that both would be used. If you need to support ; instead of &, just swap them in the regex.

If you're using a server-side preprocessing language, you might want to use its native JSON functions to do the heavy lifting for you. For example, in PHP you can write:

var urlParams = ;

Much simpler!

#UPDATED

A new capability would be to retrieve repeated params as following myparam=1&myparam=2. There is not a specification, however, most of the current approaches follow the generation of an array.

myparam = ["1", "2"]

So, this is the approach to manage it:

let urlParams = {};
[window.onpopstate = function [] {
    let 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];

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

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;
                }, {}
            ]
        : {}
};

Without 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['&']];

With an URL like ?topic=123&name=query+string, the following will return:

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

Google method

Tearing Google's code I found the method they use: 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
}

It is obfuscated, but it is understandable. It does not work because some variables are undefined.

They start to look for parameters on the url from ? and also from the hash #. Then for each parameter they split in the equal sign b[f][p]["="] [which looks like indexOf, they use the position of the char to get the key/value]. Having it split they check whether the parameter has a value or not, if it has then they store the value of d, otherwise they just continue.

In the end the object d is returned, handling escaping and the + sign. This object is just like mine, it has the same behavior.

My method 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 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¶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 test [split method against regex method] [jsPerf]

Preparation code: methods declaration

Split test code

var qs = window.GetQueryString[query];

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

Regex test code

var search = window.getParameterByName["q"];
var value = window.getParameterByName["value"];
var undef = window.getParameterByName["undefinedstring"];

Testing in 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

Firefox 44+, Opera 36+, Edge 17+, Safari 10.3+ and Chrome 49+ support the URLSearchParams API:

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

There is a google-suggested URLSearchParams polyfill for the stable versions of IE.

It is not standardized by W3C, but it is a living standard by WhatWG.

You can use it on location:

const params = new URLSearchParams[location.search];

const params = [new URL[location]].searchParams;

Or of course on any URL:

const url = new URL['//example.com?foo=1&bar=2'];
const params = new URLSearchParams[url.search];

You can get params also using a shorthand .searchParams property on the URL object, like this:

const params = new URL['//example.com?foo=1&bar=2'].searchParams;
params.get['foo']; // "1"
params.get['bar']; // "2"

You read/set parameters through the get[KEY], set[KEY, VALUE], append[KEY, VALUE] API. You can also iterate over all values for [let p of params] {}.

A reference implementation and a sample page are available for auditing and testing.

Just another recommendation. The plugin Purl allows to retrieve all parts of URL, including anchor, host, etc.

It can be used with or without jQuery.

Usage is very simple and cool:

var url = $.url['//example.com/folder/dir/index.html?item=value']; // jQuery version
var url = purl['//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, as of Nov 11, 2014, Purl is no longer maintained and the author recommends using URI.js instead. The jQuery plugin is different in that it focuses on elements - for usage with strings, just use URI directly, with or without jQuery. Similar code would look as such, fuller docs here:

var url = new URI['//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 quick, complete solution, which handles multivalued 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]]; //  null-coalescing / short-circuit
    //[k in qd] ? qd[k].push[v] : qd[k] = [v]
    [qd[k] = qd[k] || []].push[v] // null-coalescing / short-circuit
}]

What is all this code...
"null-coalescing", short-circuit evaluation
ES6 Destructuring assignments, Arrow functions, 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, "//w3schools.com/my test.asp?name=ståle&car=saab"]

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

Easiest [dummy] solution

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

Handles empty keys correctly.
Overrides multi-keys with last value found.

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

Multi-valued keys

Simple key check [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]]}]

Now returns arrays instead.
Access values by qd.key[index] or qd[key][index]

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

Encoded characters?

Use decodeURIComponent[] for the second or both splits.

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"]  // decodeURIComponent[undefined] returns "undefined" !!!*
e: ["undefined", "//w3schools.com/my test.asp?name=ståle&car=saab"]

# From comments **\*!!!** Please note, that `decodeURIComponent[undefined]` returns string `"undefined"`. The solution lies in a simple usage of [`&&`][5], which ensures that `decodeURIComponent[]` is not called on undefined values. _[See the "complete solution" at the top.]_

v = v && decodeURIComponent[v];

If the querystring is empty [`location.search == ""`], the result is somewhat misleading `qd == {"": undefined}`. It is suggested to check the querystring before launching the parsing function likeso:

if [location.search] location.search.substr[1].split["&"].forEach[...]

Roshambo on snipplr.com has a simple script to achieve this described in Get URL Parameters with jQuery | Improved. With his script you also easily get to pull out just the parameters you want.

Here's the gist:

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

Then just get your parameters from the query string.

So if the URL/query string was xyz.example/index.html?lang=de.

Just call var langval = $.urlParam['lang'];, and you've got it.

UZBEKJON has a great blog post on this as well, Get URL parameters & values with jQuery.

If you're using jQuery, you can use a library, such as jQuery BBQ: Back Button & Query Library.

...jQuery BBQ provides a full .deparam[] method, along with both hash state management, and fragment / query string parse and merge utility methods.

Edit: Adding Deparam Example:

 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 want to just use plain JavaScript, you could use...

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

}][];

Because of the new HTML History API and specifically history.pushState[] and history.replaceState[], the URL can change which will invalidate the cache of parameters and their values.

This version will update its internal cache of parameters each time the history changes.

Just use two splits:

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

I was reading all the previous and more complete answers. But I think that is the simplest and faster method. You can check in this jsPerf benchmark

To solve the problem in Rup's comment, add a conditional split by changing the first line to the two below. But absolute accuracy means it's now slower than regexp [see 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;
}

So if you know you won't run into Rup's counter-case, this wins. Otherwise, regexp.

Or if you have control of the querystring and can guarantee that a value you are trying to get will never contain any URL encoded characters [having these in a value would be a bad idea] - you can use the following slightly more simplified and readable version of the 1st option:
    function getQueryStringValueByName[name] {
        var queryStringFromStartOfValue = location.search.split[name + '='][1];
         return queryStringFromStartOfValue !== undefined ? queryStringFromStartOfValue.split['&'][0] : null;

Here's my stab at making Andy E's excellent solution into a full fledged jQuery plugin:

;[function [$] {
    $.extend[{      
        getQueryString: function [name] {           
            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[name];
        }
    }];
}][jQuery];

The syntax is:

var someVar = $.getQueryString['myParam'];

Best of both worlds!

If you're doing more URL manipulation than simply parsing the querystring, you may find URI.js helpful. It is a library for manipulating URLs - and comes with all the bells and whistles. [Sorry for self-advertising here]

to convert your querystring into a map:

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

[URI.js also "fixes" bad querystrings like ?&foo&&bar=baz& to ?foo&bar=baz]

I like Ryan Phelan's solution. But I don't see any point of extending jQuery for that? There is no usage of jQuery functionality.

On the other hand, I like the built-in function in Google Chrome: window.location.getParameter.

So why not to use this? Okay, other browsers don't have. So let's create this function if it does not exist:

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 function is more or less from Ryan Phelan, but it is wrapped differently: clear name and no dependencies of other javascript libraries. More about this function on my blog.

Here is a fast way to get an object similar to the PHP $_GET array:

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

Usage:

var $_GET = get_query[];

For the query string x=5&y&z=hello&x=6 this returns the object:

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

Keep it simple in plain JavaScript code:

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

Call it from anywhere in the JavaScript code:

var result = qs['someKey'];

From the MDN:

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

alert[loadPageVar["name"]];

These are all great answers, but I needed something a bit more robust, and thought you all might like to have what I created.

It is a simple library method that does dissection and manipulation of URL parameters. The static method has the following sub methods that can be called on the subject URL:

getHost
getPath
getHash
setHash
getParams
getQuery
setParam
getParam
hasParam
removeParam

Example:

URLParser[url].getParam['myparam1']

var url = "//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[] + '
'];
document.write["Path: " + URLParser[url].getPath[] + '
'];
document.write["Query: " + URLParser[url].getQuery[] + '
'];
document.write["Hash: " + URLParser[url].getHash[] + '
'];
document.write["Params Array: " + URLParser[url].getParams[] + '
'];
document.write["Param: " + URLParser[url].getParam['myparam1'] + '
'];
document.write["Has Param: " + URLParser[url].hasParam['myparam1'] + '
'];

document.write[url + '
'];

// Remove the first parameter
url = URLParser[url].removeParam['myparam1'];
document.write[url + ' - Remove the first parameter
'];

// Add a third parameter
url = URLParser[url].setParam['myparam3',3];
document.write[url + ' - Add a third parameter
'];

// Remove the second parameter
url = URLParser[url].removeParam['myparam2'];
document.write[url + ' - Remove the second parameter
'];

// Add a hash
url = URLParser[url].setHash['newhash'];
document.write[url + ' - Set Hash
'];

// Remove the last parameter
url = URLParser[url].removeParam['myparam3'];
document.write[url + ' - Remove the last parameter
'];

// Remove a parameter that doesn't exist
url = URLParser[url].removeParam['myparam3'];
document.write[url + ' - Remove a parameter that doesn\"t exist
'];

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

Display it!

for [i in a] {
    document.write[i + ":" + a[i] + "
"];   
};

On my Mac: test.htm?i=can&has=cheezburger displays

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

I use regular expressions a lot, but not for that.

It seems easier and more efficient to me to read the query string once in my application, and build an object from all the key/value pairs like:

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

For a URL like //example.com?param1=val1¶m2=val2 you can get their value later in your code as search.param1 and search.param2.

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

Roshambo jQuery method wasn't taking care of decode URL

//snipplr.com/view/26662/get-url-parameters-with-jquery--improved/

Just added that capability also while adding in the return statement

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

Now you can find the updated gist:

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

I like this one [taken from 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;
}

Works great for me.

Here's my edit to this excellent answer - with added ability to parse query strings with keys without values.

var url = '//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['&']];

IMPORTANT! The parameter for that function in the last line is different. It's just an example of how one can pass an arbitrary URL to it. You can use last line from Bruno's answer to parse the current URL.

So what exactly changed? With url //sb.com/reg/step1?param= results will be same. But with url //sb.com/reg/step1?param Bruno's solution returns an object without keys, while mine returns an object with key param and undefined value.

I needed an object from the query string, and I hate lots of code. It may not be the most robust in the universe, but it's just a few lines of code.

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

A URL like this.htm?hello=world&foo=bar will create:

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

Here's an extended version of Andy E's linked "Handle array-style query strings"-version. Fixed a bug [?key=1&key[]=2&key[]=3; 1 is lost and replaced with [2,3]], made a few minor performance improvements [re-decoding of values, recalculating "[" position, etc.] and added a number of improvements [functionalized, support for ?key=1&key=2, support for ; delimiters]. I left the variables annoyingly short, but added comments galore to make them readable [oh, and I reused v within the local functions, sorry if that is confusing ;].

It will handle the following querystring...

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

...making it into an object that looks like...

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

As you can see above, this version handles some measure of "malformed" arrays, i.e. - person=neek&person[]=jeff&person[]=jim or person=neek&person=jeff&person=jim as the key is identifiable and valid [at least in dotNet's NameValueCollection.Add]:

If the specified key already exists in the target NameValueCollection instance, the specified value is added to the existing comma-separated list of values in the form "value1,value2,value3".

It seems the jury is somewhat out on repeated keys as there is no spec. In this case, multiple keys are stored as an [fake]array. But do note that I do not process values based on commas into arrays.

The code:

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

This is a function I created a while back and I'm quite happy with. It is not case sensitive - which is handy. Also, if the requested QS doesn't exist, it just returns an empty string.

I use a compressed version of this. I'm posting uncompressed for the novice types to better explain what's going on.

I'm sure this could be optimized or done differently to work faster, but it's always worked great for what I need.

Enjoy.

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

If you are using Browserify, you can use the url module from Node.js:

var url = require['url'];

url.parse['//example.com/?bob=123', true].query;

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

Further reading: URL Node.js v0.12.2 Manual & Documentation

EDIT: You can use URL interface, its quite widely adopted in almost all the new browser and if the code is going to run on an old browser you can use a polyfill like this one. Here's a code example on how to use URL interface to get query parameters [aka search parameters]

const url = new URL['//example.com/?bob=123'];
url.searchParams.get['bob'];

You can also use URLSearchParams for it, here's an example from MDN 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"

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

And this is how you can use this function assuming the URL is

//example.com/?stringtext=jquery&stringword=jquerybyexample

var tech = GetQueryStringParams['stringtext'];
var blog = GetQueryStringParams['stringword'];

We've just released arg.js, a project aimed at solving this problem once and for all. It's traditionally been so difficult but now you can do:

var name = Arg.get["name"];

or getting the whole lot:

var params = Arg.all[];

and if you care about the difference between ?query=true and #hash=true then you can use the Arg.query[] and Arg.hash[] methods.

The problem with the top answer on that question is that it's not-supported parameters placed after #, but sometimes it's needed to get this value also.

I modified the answer to let it parse a full query string with a hash sign also:

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

How do you create a parameter query?

Create a parameter query.

Create a select query, and then open the query in Design view..

In the Criteria row of the field you want to apply a parameter to, enter the text that you want to display in the parameter box, enclosed in square brackets. ... .

Repeat step 2 for each field you want to add parameters to..

How do you query parameters in a URL?

Any word after the question mark [?] in a URL is considered to be a parameter which can hold values. The value for the corresponding parameter is given after the symbol "equals" [=]. Multiple parameters can be passed through the URL by separating them with multiple "&".

How will you get the query parameter search?

In the View column, click View Settings. Under Site Search Settings, set Site Search Tracking to ON. In the Query Parameter field, enter the word or words that designate internal query parameters, such as term,search,query,keywords. Sometimes query parameters are designated by just a letter, such as s or q.

Can Javascript read URL parameters?

The short answer is yes Javascript can parse URL parameter values. You can do this by leveraging URL Parameters to: Pass values from one page to another using the Javascript Get Method. Pass custom values to Google Analytics using the Google Tag Manager URL Variable which works the same as using a Javascript function.