是否有通过jQuery（或没有）检索query string值的无插件方法？
如果是这样，怎么样？如果没有，是否有插件可以这样做？
答案 0 :(得分：7670)
更新：2018年9月
您可以使用简单且具有good browser support。
的URLSearchParamsconst urlParams = new URLSearchParams(window.location.search);
const myParam = urlParams.get('myParam');
<强>原始
您不需要jQuery用于此目的。您只能使用一些纯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, ' '));
}
<强>用法：
// 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)
注意：如果参数多次出现（?foo=lorem&foo=ipsum），您将获得第一个值（lorem）。没有关于此的标准和用法不同，请参阅此问题：Authoritative position of duplicate HTTP GET query keys
注意：该功能区分大小写。如果您更喜欢不区分大小写的参数名称add 'i' modifier to RegExp
这是基于新URLSearchParams specs的更新，以更简洁地实现相同的结果。请参阅下面标题为“URLSearchParams”的回答。
答案 1 :(得分：1669)
此处发布的一些解决方案效率低下。每次脚本需要访问参数时重复正则表达式搜索是完全没有必要的，将参数拆分成关联数组样式对象的单个函数就足够了。如果您不使用HTML 5 History API，则每页加载仅需一次。此处的其他建议也无法正确解码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]);
})();示例查询字符串：
?i=main&mode=front&sid=de8d49b78a85a322c4155015fdce22c4&enc=+Hello%20&empty
结果：
urlParams = {
enc: " Hello ",
i: "main",
mode: "front",
sid: "de8d49b78a85a322c4155015fdce22c4",
empty: ""
}
alert(urlParams["mode"]);
// -> "front"
alert("empty" in urlParams);
// -> true
这也很容易改进，以处理数组样式的查询字符串。一个例子是here，但由于RFC 3986中未定义数组样式参数，因此我不会使用源代码污染此答案。 For those interested in a "polluted" version, look at campbeln's answer below
此外，正如评论中所指出的，;是key=value对的合法分隔符。这需要一个更复杂的正则表达式来处理;或&，我认为这是不必要的，因为很少使用;，我会说两者都更不可能被使用。如果您需要支持;而不是&，请在正则表达式中交换它们。
<小时/> 如果您使用的是服务器端预处理语言，则可能需要使用其本机JSON函数来为您完成繁重的工作。例如，在PHP中，您可以编写：
<script>var urlParams = <?php echo json_encode($_GET, JSON_HEX_TAG);?>;</script>更简单！
答案 2 :(得分：1246)
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;
}, {}
)
: {}
};
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('&'));
使用?topic=123&name=query+string之类的网址，以下内容将返回：
qs["topic"]; // 123
qs["name"]; // query string
qs["nothere"]; // undefined (object)
撕毁Google的代码我找到了他们使用的方法：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
}
它是混淆的，但这是可以理解的。它不起作用，因为某些变量未定义。
他们开始在?以及散列#的网址上查找参数。然后，对于每个参数，它们以等号b[f][p]("=")分割（看起来像indexOf，它们使用char的位置来获取键/值）。拆分它们会检查参数是否有值，如果有，则会存储d的值，否则它们会继续。
最后返回对象d，处理转义和+符号。这个对象就像我的一样，它具有相同的行为。
我的方法是 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);
用法
//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));
准备代码：方法声明
var qs = window.GetQueryString(query);
var search = qs["q"];
var value = qs["value"];
var undef = qs["undefinedstring"];
var search = window.getParameterByName("q");
var value = window.getParameterByName("value");
var undef = window.getParameterByName("undefinedstring");
在Windows Server 2008 R2 / 7 x64上的Firefox 4.0 x86中进行测试
答案 3 :(得分：651)
Artem Barger's answer的改进版本：
function getParameterByName(name) {
var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
}
有关改进的详细信息，请参阅：http://james.padolsey.com/javascript/bujs-1-getparameterbyname/
答案 4 :(得分：543)
Firefox 44 +，Opera 36 +，Edge 17 +，Safari 10.3+和Chrome 49+支持URLSearchParams API：
对于稳定版本的IE，有一个谷歌建议的 URLSearchParams polyfill 。
您可以在地点使用它，但需要移除?问号（例如，使用.slice(1)）：
let params = new URLSearchParams(location.search);
或
let params = (new URL(location)).searchParams;
当然还有任何网址：
let url = new URL('https://example.com?foo=1&bar=2');
let params = new URLSearchParams(url.search);
你也可以在URL对象上使用简写.searchParams属性获取params，如下所示：
let params = new URL('https://example.com?foo=1&bar=2').searchParams;
params.get('foo'); // "1"
params.get('bar'); // "2"
您通过get(KEY)，set(KEY, VALUE)，append(KEY, VALUE) API读取/设置参数。您还可以迭代所有值for (let p of params) {}。
reference implementation和sample page可用于审核和测试。
答案 5 :(得分：398)
另一个建议。插件 Purl 允许检索URL的所有部分，包括锚点，主机等。
它可以在有或没有jQuery的情况下使用。
用法很简单，很酷：
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'
但是，截至2014年11月11日，Purl已不再维护，作者建议使用URI.js代替。 jQuery插件的不同之处在于它专注于元素 - 用于字符串，只需直接使用URI，有或没有jQuery。类似的代码看起来如此，更全面的文档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'
答案 6 :(得分：232)
快速，完整解决方案，可处理多值密钥和编码字符。
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)})
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
})
这些代码是什么......
"null-coalescing"，short-circuit evaluation
ES6 Destructuring assignments，Arrow functions，Template strings
"?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"
要访问网址的不同部分，请使用location.(search|hash)
var queryDict = {};
location.search.substr(1).split("&").forEach(function(item) {queryDict[item.split("=")[0]] = item.split("=")[1]})
"?a=1&b=0&c=3&d&e&a=5"
> queryDict
a: "5"
b: "0"
c: "3"
d: undefined
e: undefined
简单密钥检查(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]]})
qd.key[index]或qd[key][index] > qd
a: ["1", "5"]
b: ["0"]
c: ["3"]
d: [undefined]
e: [undefined]
将decodeURIComponent()用于第二个或两个拆分。
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]})
"?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", "http://w3schools.com/my test.asp?name=ståle&car=saab"]
* !!! 请注意，decodeURIComponent(undefined)会返回字符串"undefined"。解决方案在于&&的简单用法，它确保不会在未定义的值上调用decodeURIComponent()。 （请参阅顶部的“完整解决方案”。）
v = v && decodeURIComponent(v);
如果查询字符串为空（location.search == ""），则结果会有些误导qd == {"": undefined}。建议在启动解析函数之前检查查询字符串：
if (location.search) location.search.substr(1).split("&").forEach(...)
答案 7 :(得分：216)
snipplr.com上的Roshambo有一个简单的脚本来实现 Get URL Parameters with jQuery | Improved 中描述的内容。使用他的脚本，您也可以轻松获得所需的参数。
这是要点：
$.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;
}
然后从查询字符串中获取参数。
因此，如果网址/查询字符串为xyz.com/index.html?lang=de。
只需致电var langval = $.urlParam('lang');，就可以了。
UZBEKJON也有一篇很棒的博文， Get URL parameters & values with jQuery 。
答案 8 :(得分：166)
如果您使用的是jQuery，则可以使用库，例如jQuery BBQ: Back Button & Query Library。
... jQuery BBQ提供了一个完整的
.deparam()方法，以及散列状态管理和片段/查询字符串解析和合并实用程序方法。
编辑：添加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();
}
};
如果您只想使用纯JavaScript，可以使用...
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;
}
})();
由于新的HTML历史记录API，特别是history.pushState()和history.replaceState()，因此URL可能会更改，这会使参数及其值的缓存无效。
每次历史记录更改时，此版本都会更新其内部参数缓存。
答案 9 :(得分：99)
只需使用两个拆分：
function get(n) {
var half = location.search.split(n + '=')[1];
return half !== undefined ? decodeURIComponent(half.split('&')[0]) : null;
}
我正在阅读所有之前和更完整的答案。但我认为这是最简单，更快捷的方法。您可以签入此jsPerf benchmark
要解决Rup注释中的问题，请通过将第一行更改为下面的两行来添加条件分割。但绝对准确性意味着它现在比正则表达式慢（见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;
}
所以，如果你知道你不会遇到Rup的反案，那就赢了。否则，regexp。
或如果您可以控制查询字符串，并且可以保证您尝试获取的值永远不会包含任何编码的URL 字符（在值中有这些是一个坏主意） - 你可以使用 以下稍微更简化和可读的第一个选项版本：
function getQueryStringValueByName(name) { var queryStringFromStartOfValue = location.search.split(name + '=')[1]; return queryStringFromStartOfValue !== undefined ? queryStringFromStartOfValue.split('&')[0] : null;
答案 10 :(得分：94)
这是我将Andy E的优秀解决方案变成一个完整的jQuery插件：
;(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);
语法为：
var someVar = $.getQueryString('myParam');
两全其美！
答案 11 :(得分：76)
如果您正在进行更多的URL操作，而不仅仅是解析查询字符串，您可能会发现URI.js有用。它是一个用于操纵URL的库 - 并附带所有的铃声和口哨声。 （对不起，这里有自我宣传）
将您的查询字符串转换为地图：
var data = URI('?foo=bar&bar=baz&foo=world').query(true);
data == {
"foo": ["bar", "world"],
"bar": "baz"
}
（URI.js还“修复”?&foo&&bar=baz&到?foo&bar=baz等错误的查询字符串
答案 12 :(得分：59)
我喜欢Ryan Phelan's solution。但我没有看到任何扩展jQuery的意义吗？没有使用jQuery功能。
另一方面，我喜欢Google Chrome中的内置功能：window.location.getParameter。
那么为什么不使用它呢？好的，其他浏览器没有。所以，如果它不存在，让我们创建这个函数：
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];
};
}
这个功能或多或少来自Ryan Phelan，但它的包装方式不同：清晰的名称和其他javascript库的依赖关系。 More about this function on my blog
答案 13 :(得分：53)
这是获取类似于PHP $_GET数组的对象的快速方法：
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;
}
用法：
var $_GET = get_query();
对于查询字符串x=5&y&z=hello&x=6，它返回对象：
{
x: "6",
y: undefined,
z: "hello"
}
答案 14 :(得分：52)
在纯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];
}
从JavaScript代码中的任何位置调用它：
var result = qs('someKey');
答案 15 :(得分：46)
这些都是很好的答案，但我需要更强大的东西，并且认为你们都希望得到我创造的东西。
这是一个简单的库方法，可以解析和操作URL参数。静态方法具有以下子方法，可以在主题URL上调用：
示例：
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>');
答案 16 :(得分：43)
来自the MDN：
function loadPageVar (sVar) {
return unescape(window.location.search.replace(new RegExp("^(?:.*[&\\?]" + escape(sVar).replace(/[\.\+\*]/g, "\\$&") + "(?:\\=([^&]*))?)?.*$", "i"), "$1"));
}
alert(loadPageVar("name"));
答案 17 :(得分：39)
我经常使用正则表达式，但不是那样。
在我的应用程序中读取一次查询字符串似乎更容易，更有效，并从所有键/值对构建对象，如：
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;
}();
对于http://domain.com?param1=val1¶m2=val2这样的网址，您可以在代码中稍后将其值search.param1和search.param2获取。
答案 18 :(得分：39)
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]);
}
显示它！
for (i in a) {
document.write(i + ":" + a[i] + "<br/>");
};
在我的Mac上：test.htm?i=can&has=cheezburger显示
0:can
1:cheezburger
i:can
has:cheezburger
答案 19 :(得分：38)
Roshambo jQuery方法没有处理解码URL
http://snipplr.com/view/26662/get-url-parameters-with-jquery--improved/
在添加return语句时添加该功能
return decodeURIComponent(results[1].replace(/\+/g, " ")) || 0;
现在你可以找到更新的要点：
$.urlParam = function(name){
var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(window.location.href);
if (!results) { return 0; }
return decodeURIComponent(results[1].replace(/\+/g, " ")) || 0;
}
答案 20 :(得分：38)
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
答案 21 :(得分：36)
这是我对this excellent answer的编辑 - 增加了使用没有值的键解析查询字符串的功能。
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('&'));
重要！最后一行中该功能的参数不同。这只是一个如何将任意URL传递给它的示例。您可以使用Bruno的答案的最后一行来解析当前的URL。
那究竟发生了什么变化？使用网址http://sb.com/reg/step1?param=，结果将相同。但是使用url http://sb.com/reg/step1?param Bruno的解决方案返回一个没有键的对象，而我的返回一个键为param和undefined的对象。
答案 22 :(得分：36)
我喜欢this one（取自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;
}
非常适合我。
答案 23 :(得分：34)
我需要查询字符串中的对象，我讨厌很多代码。它可能不是宇宙中最强大的，但它只是几行代码。
var q = {};
location.href.split('?')[1].split('&').forEach(function(i){
q[i.split('=')[0]]=i.split('=')[1];
});
像this.htm?hello=world&foo=bar这样的网址会创建：
{hello:'world', foo:'bar'}
答案 24 :(得分：31)
这是我前段时间创作的一个功能，我很满意。它不区分大小写 - 这很方便。此外，如果请求的QS不存在，它只返回一个空字符串。
我使用的是压缩版本。我为新手类型发布了未压缩的帖子，以便更好地解释发生了什么。
我确信这可以进行优化或以不同方式完成更快的工作，但它总是能够满足我的需求。
享受。
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);
}
答案 25 :(得分：31)
这是Andy E的链接＆＃34; Handle数组式查询字符串＆＃34; -version的扩展版本。修复了一个错误（?key=1&key[]=2&key[]=3; 1丢失并替换为[2,3]），进行了一些小的性能改进（重新解码值，重新计算＆＃34; [＆＃34;位置等）并添加了许多改进（功能化，支持?key=1&key=2，支持;分隔符）。我把这些变量简单地留了下来，但添加了很多评论以使它们具有可读性（哦，我在本地函数中重用v，对不起，如果这让人感到困惑;）。
它将处理以下查询字符串......
？测试=你好＆安培;人= NEEK＆安培;人[] =杰夫＆安培;人[] =吉姆＆安培;人[额外] =约翰＆安培; TEST3＆安培;非缓存= 1398914891264
......将它变成一个看似......的对象。
{
"test": "Hello",
"person": {
"0": "neek",
"1": "jeff",
"2": "jim",
"length": 3,
"extra": "john"
},
"test3": "",
"nocache": "1398914891264"
}
正如您在上面所看到的，这个版本处理了一些＆＃34;格式错误的＆＃34;数组，即 - person=neek&person[]=jeff&person[]=jim或person=neek&person=jeff&person=jim，因为密钥是可识别且有效的（至少在dotNet＆＃39; s NameValueCollection.Add中）：
如果指定的密钥已存在于目标NameValueCollection中 实例，将指定的值添加到现有的逗号分隔中 表格中的值列表＆＃34; value1，value2，value3＆＃34;。
重复键似乎the jury is somewhat out，因为没有规格。在这种情况下，多个密钥存储为（假）数组。但请注意，我不将基于逗号的值处理为数组。
代码：
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;
};
答案 26 :(得分：27)
关于该问题的最佳答案的问题是它是在＃之后放置的不受支持的参数，但有时也需要获得此值。
我修改了答案，让它解析带有井号的完整查询字符串：
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;
};
答案 27 :(得分：27)
我们刚刚发布了arg.js，这是一个旨在一劳永逸地解决这个问题的项目。它传统上一直很困难，但现在你可以做到：
var name = Arg.get("name");
或获得全部：
var params = Arg.all();
如果您关心?query=true和#hash=true之间的区别，那么您可以使用Arg.query()和Arg.hash()方法。
答案 28 :(得分：25)
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];
}
}
}
假设URL为
，这就是你可以使用这个函数的方法
http://dummy.com/?stringtext=jquery&stringword=jquerybyexample
var tech = GetQueryStringParams('stringtext');
var blog = GetQueryStringParams('stringword');
答案 29 :(得分：20)
如果您使用的是Browserify，则可以使用 Node.js 中的url模块：
var url = require('url');
url.parse('http://example.com/?bob=123', true).query;
// returns { "bob": "123" }
进一步阅读：URL Node.js v0.12.2 Manual & Documentation
编辑：您可以使用URL界面，它几乎在所有新浏览器中广泛采用，如果代码将在旧浏览器上运行，您可以使用{{ 3}}。这是关于如何使用URL接口获取查询参数（也称为搜索参数）的代码示例
const url = new URL('http://example.com/?bob=123');
url.searchParams.get('bob');
您也可以使用URLSearchParams，这里polyfill like this one使用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"
答案 30 :(得分：20)
获取查询的单行：
var value = location.search.match(new RegExp(key + "=(.*?)($|\&)", "i"))[1];
答案 31 :(得分：20)
我使用此处列出的技术开发了一个小型库，为任何人的问题创建一个易于使用的简单解决方案;它可以在这里找到：
https://github.com/Nijikokun/query-js
<强>用法
获取特定参数/键：
query.get('param');
使用构建器获取整个对象：
var storage = query.build();
console.log(storage.param);
以及更多...查看github链接以获取更多示例。
功能
#hello?page=3 user[]="jim"&user[]="bob" && name&hello="world" param=1¶m=2 4kb 答案 32 :(得分：20)
http://someurl.com?key=value&keynovalue&keyemptyvalue=&&keynovalue=nowhasvalue#somehash
?param=value）?param：没有等号或值）?param=：等号，但等号右边没有值）?param=1¶m=2）?&&：无键或值）var queryString = window.location.search || '';
var keyValPairs = [];
var params = {};
queryString = queryString.substr(1);
if (queryString.length)
{
keyValPairs = queryString.split('&');
for (pairNum in keyValPairs)
{
var key = keyValPairs[pairNum].split('=')[0];
if (!key.length) continue;
if (typeof params[key] === 'undefined')
params[key] = [];
params[key].push(keyValPairs[pairNum].split('=')[1]);
}
}
params['key']; // returns an array of values (1..n)
key ["value"]
keyemptyvalue [""]
keynovalue [undefined, "nowhasvalue"]
答案 33 :(得分：17)
非常轻量级的jQuery方法：
var qs = window.location.search.replace('?','').split('&'),
request = {};
$.each(qs, function(i,v) {
var initial, pair = v.split('=');
if(initial = request[pair[0]]){
if(!$.isArray(initial)) {
request[pair[0]] = [initial]
}
request[pair[0]].push(pair[1]);
} else {
request[pair[0]] = pair[1];
}
return;
});
console.log(request);
并提醒，例如？q
alert(request.q)
答案 34 :(得分：16)
这是my version of query string parsing code on GitHub。
它与jquery。*“前缀”，但解析函数本身不使用jQuery。它非常快，但仍然可以进行简单的性能优化。
它还支持list＆amp; URL中的哈希表编码，如：
arr[]=10&arr[]=20&arr[]=100
或
hash[key1]=hello&hash[key2]=moto&a=How%20are%20you
jQuery.toQueryParams = function(str, separator) {
separator = separator || '&'
var obj = {}
if (str.length == 0)
return obj
var c = str.substr(0,1)
var s = c=='?' || c=='#' ? str.substr(1) : str;
var a = s.split(separator)
for (var i=0; i<a.length; i++) {
var p = a[i].indexOf('=')
if (p < 0) {
obj[a[i]] = ''
continue
}
var k = decodeURIComponent(a[i].substr(0,p)),
v = decodeURIComponent(a[i].substr(p+1))
var bps = k.indexOf('[')
if (bps < 0) {
obj[k] = v
continue;
}
var bpe = k.substr(bps+1).indexOf(']')
if (bpe < 0) {
obj[k] = v
continue;
}
var bpv = k.substr(bps+1, bps+bpe-1)
var k = k.substr(0,bps)
if (bpv.length <= 0) {
if (typeof(obj[k]) != 'object') obj[k] = []
obj[k].push(v)
} else {
if (typeof(obj[k]) != 'object') obj[k] = {}
obj[k][bpv] = v
}
}
return obj;
}
答案 35 :(得分：12)
以下是我正在使用的内容：
/**
* Examples:
* getUrlParams()['myparam'] // url defaults to the current page
* getUrlParams(url)['myparam'] // url can be just a query string
*
* Results of calling `getUrlParams(url)['myparam']` with various urls:
* example.com (undefined)
* example.com? (undefined)
* example.com?myparam (empty string)
* example.com?myparam= (empty string)
* example.com?myparam=0 (the string '0')
* example.com?myparam=0&myparam=override (the string 'override')
*
* Origin: http://stackoverflow.com/a/23946023/2407309
*/
function getUrlParams (url) {
var urlParams = {} // return value
var queryString = getQueryString()
if (queryString) {
var keyValuePairs = queryString.split('&')
for (var i = 0; i < keyValuePairs.length; i++) {
var keyValuePair = keyValuePairs[i].split('=')
var paramName = keyValuePair[0]
var paramValue = keyValuePair[1] || ''
urlParams[paramName] = decodeURIComponent(paramValue.replace(/\+/g, ' '))
}
}
return urlParams // functions below
function getQueryString () {
var reducedUrl = url || window.location.search
reducedUrl = reducedUrl.split('#')[0] // Discard fragment identifier.
var queryString = reducedUrl.split('?')[1]
if (!queryString) {
if (reducedUrl.search('=') !== false) { // URL is a query string.
queryString = reducedUrl
}
}
return queryString
} // getQueryString
} // getUrlParams
在最后一种情况下返回'override'而不是'0'使其与PHP保持一致。适用于IE7。
答案 36 :(得分：11)
我宁愿使用split()代替Regex进行此操作：
function getUrlParams() {
var result = {};
var params = (window.location.search.split('?')[1] || '').split('&');
for(var param in params) {
if (params.hasOwnProperty(param)) {
var paramParts = params[param].split('=');
result[paramParts[0]] = decodeURIComponent(paramParts[1] || "");
}
}
return result;
}
答案 37 :(得分：10)
获取所有查询字符串参数，包括复选框值（数组）。
考虑到正确的＆amp;正常使用GET参数，在大多数函数中，我看到它缺失的是对数组的支持和删除哈希数据。
所以我写了这个函数：
function qs(a){
if(!a)return {};
a=a.split('#')[0].split('&');
var b=a.length,c={},d,k,v;
while(b--){
d=a[b].split('=');
k=d[0].replace('[]',''),v=decodeURIComponent(d[1]||'');
c[k]?typeof c[k]==='string'?(c[k]=[v,c[k]]):(c[k].unshift(v)):c[k]=v;
}
return c
}
使用速记运算符＆amp; while--循环，性能应该非常好。
<强>支持：
备注：
它不支持对象数组（key [key] = value）
如果空格为+，则保持为+。
如果需要，请添加.replace(/\+/g, " ")。
<强>用法：
qs('array[]=1&array[]=2&key=value&empty=&empty2#hash')
<强>返回：
{
"empty": "",
"key": "value",
"array": [
"1",
"2"
]
}
<强>演示：
<强>信息
如果您不理解某些内容或者您无法阅读该功能，请询问。我很高兴解释我在这里做了什么。
如果您认为该功能不可读且无法维护，我很乐意为您重写该功能，但请考虑这个简写＆amp;按位运算符总是比标准语法更快（可能会阅读ECMA-262书中的短号和按位运算符或使用您最喜欢的搜索引擎）。用标准可读语法重写代码意味着性能损失。
答案 38 :(得分：10)
对于那些想要一个简短方法（有限制）的人：
location.search.split('myParameter=')[1]
答案 39 :(得分：9)
这个工作正常
function getQuerystring(key) {
var query = window.location.search.substring(1);
var vars = query.split("&");
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split("=");
if (pair[0] == key) {
return pair[1];
}
}
}
取自here
答案 40 :(得分：8)
function getUrlVar(key){
var result = new RegExp(key + "=([^&]*)", "i").exec(window.location.search);
return result && unescape(result[1]) || "";
}
答案 41 :(得分：6)
我使用此代码（JavaScript）来获取通过URL传递的内容：
function getUrlVars() {
var vars = {};
var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) {
vars[key] = value;
});
return vars;
}
然后要将值赋给变量，您只需指定要获取的参数，即URL是example.com/?I=1&p=2&f=3
您可以这样做以获取值：
var getI = getUrlVars()["I"];
var getP = getUrlVars()["p"];
var getF = getUrlVars()["f"];
那么值将是：
getI = 1, getP = 2 and getF = 3
答案 42 :(得分：6)
以下代码将创建一个具有两种方法的对象：
isKeyExist：检查是否存在特定参数getValue：获取特定参数的值。
var QSParam = new function() {
var qsParm = {};
var query = window.location.search.substring(1);
var params = query.split('&');
for (var i = 0; i < params.length; i++) {
var pos = params[i].indexOf('=');
if (pos > 0) {
var key = params[i].substring(0, pos);
var val = params[i].substring(pos + 1);
qsParm[key] = val;
}
}
this.isKeyExist = function(query){
if(qsParm[query]){
return true;
}
else{
return false;
}
};
this.getValue = function(query){
if(qsParm[query])
{
return qsParm[query];
}
throw "URL does not contain query "+ query;
}
};
答案 43 :(得分：6)
试试这个：
String.prototype.getValueByKey = function(k){
var p = new RegExp('\\b'+k+'\\b','gi');
return this.search(p) != -1 ? decodeURIComponent(this.substr(this.search(p)+k.length+1).substr(0,this.substr(this.search(p)+k.length+1).search(/(&|;|$)/))) : "";
};
然后这样称呼它：
if(location.search != "") location.search.getValueByKey("id");
您也可以将此用于 Cookie ：
if(navigator.cookieEnabled) document.cookie.getValueByKey("username");
这仅适用于key=value[&|;|$]的字符串...不适用于对象/数组。
如果您不想要使用 String.prototype ... 将它移动到一个函数并将该字符串作为参数传递
答案 44 :(得分：6)
此函数将查询字符串转换为类似JSON的对象，它还处理无值和多值参数：
"use strict";
function getQuerystringData(name) {
var data = { };
var parameters = window.location.search.substring(1).split("&");
for (var i = 0, j = parameters.length; i < j; i++) {
var parameter = parameters[i].split("=");
var parameterName = decodeURIComponent(parameter[0]);
var parameterValue = typeof parameter[1] === "undefined" ? parameter[1] : decodeURIComponent(parameter[1]);
var dataType = typeof data[parameterName];
if (dataType === "undefined") {
data[parameterName] = parameterValue;
} else if (dataType === "array") {
data[parameterName].push(parameterValue);
} else {
data[parameterName] = [data[parameterName]];
data[parameterName].push(parameterValue);
}
}
return typeof name === "string" ? data[name] : data;
}
我们会对undefined上的parameter[1]执行检查，因为如果变量为decodeURIComponent，则undefined会返回字符串“undefined”，而这是错误的。
用法：
"use strict";
var data = getQuerystringData();
var parameterValue = getQuerystringData("parameterName");
答案 45 :(得分：5)
我在这里为我的需求做了一个小型URL库：https://github.com/Mikhus/jsurl
这是在JavaScript中操纵URL的更常见方式。同时它非常轻量级（缩小和gzip压缩<1 KB）并且具有非常简单和干净的API。它不需要任何其他库来工作。
关于最初的问题，这很简单：
var u = new Url; // Current document URL
// or
var u = new Url('http://user:pass@example.com:8080/some/path?foo=bar&bar=baz#anchor');
// Looking for query string parameters
alert( u.query.bar);
alert( u.query.foo);
// Modifying query string parameters
u.query.foo = 'bla';
u.query.woo = ['hi', 'hey']
alert(u.query.foo);
alert(u.query.woo);
alert(u);
答案 46 :(得分：5)
这是我对此的看法。第一个函数将URL字符串解码为名称/值对的对象：
url_args_decode = function (url) {
var args_enc, el, i, nameval, ret;
ret = {};
// use the DOM to parse the URL via an 'a' element
el = document.createElement("a");
el.href = url;
// strip off initial ? on search and split
args_enc = el.search.substring(1).split('&');
for (i = 0; i < args_enc.length; i++) {
// convert + into space, split on =, and then decode
args_enc[i].replace(/\+/g, ' ');
nameval = args_enc[i].split('=', 2);
ret[decodeURIComponent(nameval[0])]=decodeURIComponent(nameval[1]);
}
return ret;
};
另外一个额外的好处是，如果你更改了一些args，你可以使用第二个函数将args数组放回到URL字符串中：
url_args_replace = function (url, args) {
var args_enc, el, name;
// use the DOM to parse the URL via an 'a' element
el = document.createElement("a");
el.href = url;
args_enc = [];
// encode args to go into url
for (name in args) {
if (args.hasOwnProperty(name)) {
name = encodeURIComponent(name);
args[name] = encodeURIComponent(args[name]);
args_enc.push(name + '=' + args[name]);
}
}
if (args_enc.length > 0) {
el.search = '?' + args_enc.join('&');
} else {
el.search = '';
}
return el.href;
};
答案 47 :(得分：5)
以下函数返回queryString的对象版本。
您只需撰写obj.key1和obj.key2即可在参数中访问key1和key2的值。
function getQueryStringObject()
{
var querystring = document.location.search.replace('?','').split( '&' );
var objQueryString={};
var key="",val="";
if(typeof querystring == 'undefined')
{
return (typeof querystring);
}
for(i=0;i<querystring.length;i++)
{
key=querystring[i].split("=")[0];
val=querystring[i].split("=")[1];
objQueryString[key] = val;
}
return objQueryString;
}
要使用此功能，您可以编写
var obj= getQueryStringObject();
alert(obj.key1);
答案 48 :(得分：4)
使用纯JavaScript和regular expressions的简单解决方案：
alert(getQueryString("p2"));
function getQueryString (Param) {
return decodeURI("http://www.example.com/?p1=p11&p2=p2222".replace(new RegExp("^(?:.*[&?]" + encodeURI(Param).replace(/[.+*]/g, "$&") + "(?:=([^&]*))?)?.*$", "i"), "$1"));
}
答案 49 :(得分：4)
如果你有Underscore.js或lodash，那么快速而又肮脏的方法就是：
_.object(window.location.search.slice(1).split('&').map(function (val) { return val.split('='); }));
答案 50 :(得分：4)
我使用this answer并添加了对可选地将URL作为参数传递的支持;回到window.location.search。显然，这对于从不是当前页面的URL获取查询字符串参数很有用：
(function($, undef) {
$.QueryString = function(url) {
var pairs, qs = null, index, map = {};
if(url == undef){
qs = window.location.search.substr(1);
}else{
index = url.indexOf('?');
if(index == -1) return {};
qs = url.substring(index+1);
}
pairs = qs.split('&');
if (pairs == "") return {};
for (var i = 0; i < pairs.length; ++i)
{
var p = pairs[i].split('=');
if(p.length != 2) continue;
map[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
}
return map;
};
})(jQuery);
答案 51 :(得分：4)
有很多解决方案可以检索URI查询值，我更喜欢这个，因为它简短而且效果很好：
function get(name){
if(name=(new RegExp('[?&]'+encodeURIComponent(name)+'=([^&]*)')).exec(location.search))
return decodeURIComponent(name[1]);
}
答案 52 :(得分：4)
有一个很好的小url实用程序，有一些很酷的糖：
http://www.example.com/path/index.html?silly=willy#chucky=cheese
url(); // http://www.example.com/path/index.html?silly=willy#chucky=cheese
url('domain'); // example.com
url('1'); // path
url('-1'); // index.html
url('?'); // silly=willy
url('?silly'); // willy
url('?poo'); // (an empty string)
url('#'); // chucky=cheese
url('#chucky'); // cheese
url('#poo'); // (an empty string)
查看更多示例并在此处下载：https://github.com/websanova/js-url#url
答案 53 :(得分：4)
Node.js的源代码中有一个强大的实现 https://github.com/joyent/node/blob/master/lib/querystring.js
同样TJ的qs嵌套params解析
https://github.com/visionmedia/node-querystring
答案 54 :(得分：4)
var getUrlParameters = function (name, url) {
if (!name) {
return undefined;
}
name = name.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
url = url || location.search;
var regex = new RegExp('[\\?&#]' + name + '=?([^&#]*)', 'gi'), result, resultList = [];
while (result = regex.exec(url)) {
resultList.push(decodeURIComponent(result[1].replace(/\+/g, ' ')));
}
return resultList.length ? resultList.length === 1 ? resultList[0] : resultList : undefined;
};
答案 55 :(得分：4)
这是从URL中获取int和String参数值的最简单和最小的函数JavaScript
/* THIS FUNCTION IS TO FETCH INT PARAMETER VALUES */
function getParameterint(param) {
var val = document.URL;
var url = val.substr(val.indexOf(param))
var n=parseInt(url.replace(param+"=",""));
alert(n);
}
getParameteraint("page");
getParameteraint("pagee");
/*THIS FUNCTION IS TO FETCH STRING PARAMETER*/
function getParameterstr(param) {
var val = document.URL;
var url = val.substr(val.indexOf(param))
var n=url.replace(param+"=","");
alert(n);
}
getParameterstr("str");
来源和演示： http://bloggerplugnplay.blogspot.in/2012/08/how-to-get-url-parameter-in-javascript.html
答案 56 :(得分：4)
我认为这是实现这一目标的准确而简洁的方法（从http://css-tricks.com/snippets/javascript/get-url-variables/修改）：
function getQueryVariable(variable) {
var query = window.location.search.substring(1), // Remove the ? from the query string.
vars = query.split("&"); // Split all values by ampersand.
for (var i = 0; i < vars.length; i++) { // Loop through them...
var pair = vars[i].split("="); // Split the name from the value.
if (pair[0] == variable) { // Once the requested value is found...
return ( pair[1] == undefined ) ? null : pair[1]; // Return null if there is no value (no equals sign), otherwise return the value.
}
}
return undefined; // Wasn't found.
}
答案 57 :(得分：4)
如果你想要数组样式参数URL.js支持任意嵌套的数组样式参数以及字符串索引（maps）。它还处理URL解码。
url.get("val[0]=zero&val[1]=one&val[2]&val[3]=&val[4]=four&val[5][0]=n1&val[5][1]=n2&val[5][2]=n3&key=val", {array:true});
// Result
{
val: [
'zero',
'one',
true,
'',
'four',
[ 'n1', 'n2', 'n3' ]
]
key: 'val'
}
答案 58 :(得分：3)
这是获取参数值（查询字符串）
的非常简单的方法使用gV(para_name)函数检索其值
var a=window.location.search;
a=a.replace(a.charAt(0),""); //Removes '?'
a=a.split("&");
function gV(x){
for(i=0;i<a.length;i++){
var b=a[i].substr(0,a[i].indexOf("="));
if(x==b){
return a[i].substr(a[i].indexOf("=")+1,a[i].length)}
答案 59 :(得分：3)
最漂亮但基本的：
data = {};
$.each(
location.search.substr(1).split('&').filter(Boolean).map(function(kvpairs){
return kvpairs.split('=')
}),
function(i,values) {
data[values.shift()] = values.join('=')
}
);
它不会处理?a[]=1&a[]2
答案 60 :(得分：3)
如果您不想使用JavaScript库，可以使用JavaScript字符串函数来解析window.location。将此代码保存在外部.js文件中，您可以在不同的项目中反复使用它。
// Example - window.location = "index.htm?name=bob";
var value = getParameterValue("name");
alert("name = " + value);
function getParameterValue(param)
{
var url = window.location;
var parts = url.split('?');
var params = parts[1].split('&');
var val = "";
for ( var i=0; i<params.length; i++)
{
var paramNameVal = params[i].split('=');
if ( paramNameVal[0] == param )
{
val = paramNameVal[1];
}
}
return val;
}
答案 61 :(得分：2)
使用：
$(document).ready(function () {
var urlParams = {};
(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);
while (match = search.exec(query))
urlParams[decode(match[1])] = decode(match[2]);
})();
if (urlParams["q1"] === 1) {
return 1;
}
请检查并告诉我您的意见。另请参阅 How to get querystring value using jQuery 。
答案 62 :(得分：2)
我推荐Dar Lessons作为一个好的插件。我已经和它一起工作了很长时间。您还可以使用以下代码。
Jus将var queryObj = {};放在document.ready之前，并将下面的代码放在document.ready的开头。在此代码之后，您可以将queryObj["queryObjectName"]用于您拥有的任何查询对象
var querystring = location.search.replace('?', '').split('&');
for (var i = 0; i < querystring.length; i++) {
var name = querystring[i].split('=')[0];
var value = querystring[i].split('=')[1];
queryObj[name] = value;
}
答案 63 :(得分：2)
这将解析URL字符串中的变量 AND 数组。它既不使用正则表达式也不使用任何外部库。
function url2json(url) {
var obj={};
function arr_vals(arr){
if (arr.indexOf(',') > 1){
var vals = arr.slice(1, -1).split(',');
var arr = [];
for (var i = 0; i < vals.length; i++)
arr[i]=vals[i];
return arr;
}
else
return arr.slice(1, -1);
}
function eval_var(avar){
if (!avar[1])
obj[avar[0]] = '';
else
if (avar[1].indexOf('[') == 0)
obj[avar[0]] = arr_vals(avar[1]);
else
obj[avar[0]] = avar[1];
}
if (url.indexOf('?') > -1){
var params = url.split('?')[1];
if(params.indexOf('&') > 2){
var vars = params.split('&');
for (var i in vars)
eval_var(vars[i].split('='));
}
else
eval_var(params.split('='));
}
return obj;
}
示例：
var url = "http://www.x.com?luckyNums=[31,21,6]&name=John&favFoods=[pizza]&noVal"
console.log(url2json(url));
输出：
[object]
noVal: ""
favFoods: "pizza"
name: "John"
luckyNums:
0: "31"
1: "21"
2: "6"
答案 64 :(得分：2)
获取查询对象的大小方面的最短表达式似乎是：
var params = {};
location.search.substr(1).replace(/([^&=]*)=([^&]*)&?/g,
function () { params[decodeURIComponent(arguments[1])] = decodeURIComponent(arguments[2]); });
您可以使用A元素将字符串中的URI解析为其location类组件（例如，摆脱#...）：
var a = document.createElement('a');
a.href = url;
// Parse a.search.substr(1)... as above
答案 65 :(得分：1)
此函数将根据需要使用递归返回带有任意嵌套值的已解析JavaScript对象。
这是一个jsfiddle示例。
[
'?a=a',
'&b=a',
'&b=b',
'&c[]=a',
'&c[]=b',
'&d[a]=a',
'&d[a]=x',
'&e[a][]=a',
'&e[a][]=b',
'&f[a][b]=a',
'&f[a][b]=x',
'&g[a][b][]=a',
'&g[a][b][]=b',
'&h=%2B+%25',
'&i[aa=b',
'&i[]=b',
'&j=',
'&k',
'&=l',
'&abc=foo',
'&def=%5Basf%5D',
'&ghi=[j%3Dkl]',
'&xy%3Dz=5',
'&foo=b%3Dar',
'&xy%5Bz=5'
].join('');
鉴于以上任何测试示例。
var qs = function(a) {
var b, c, e;
b = {};
c = function(d) {
return d && decodeURIComponent(d.replace(/\+/g, " "));
};
e = function(f, g, h) {
var i, j, k, l;
h = h ? h : null;
i = /(.+?)\[(.+?)?\](.+)?/g.exec(g);
if (i) {
[j, k, l] = [i[1], i[2], i[3]]
if (k === void 0) {
if (f[j] === void 0) {
f[j] = [];
}
f[j].push(h);
} else {
if (typeof f[j] !== "object") {
f[j] = {};
}
if (l) {
e(f[j], k + l, h);
} else {
e(f[j], k, h);
}
}
} else {
if (f.hasOwnProperty(g)) {
if (Array.isArray(f[g])) {
f[g].push(h);
} else {
f[g] = [].concat.apply([f[g]], [h]);
}
} else {
f[g] = h;
}
return f[g];
}
};
a.replace(/^(\?|#)/, "").replace(/([^#&=?]+)?=?([^&=]+)?/g, function(m, n, o) {
n && e(b, c(n), c(o));
});
return b;
};
答案 66 :(得分：1)
以下是String原型实现：
String.prototype.getParam = function( str ){
str = str.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
var regex = new RegExp( "[\\?&]*"+str+"=([^&#]*)" );
var results = regex.exec( this );
if( results == null ){
return "";
} else {
return results[1];
}
}
示例电话：
var status = str.getParam("status")
str可以是查询字符串或网址
答案 67 :(得分：1)
快速，简单，快速：
功能：
function getUrlVar() {
var result = {};
var location = window.location.href.split('#');
var parts = location[0].replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) {
result [key] = value;
});
return result;
}
<强>用法：
var varRequest = getUrlVar()["theUrlVarName"];
答案 68 :(得分：1)
这对我不起作用，我希望匹配?b因为b参数存在，而不匹配?return作为r参数，这里是my solution
window.query_param = function(name) {
var param_value, params;
params = location.search.replace(/^\?/, '');
params = _.map(params.split('&'), function(s) {
return s.split('=');
});
param_value = _.select(params, function(s) {
return s.first === name;
})[0];
if (param_value) {
return decodeURIComponent(param_value[1] || '');
} else {
return null;
}
};
答案 69 :(得分：1)
请参阅此post或使用此信息：
<script type="text/javascript" language="javascript">
$(document).ready(function()
{
var urlParams = {};
(function ()
{
var 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))
urlParams[decode(match[1])] = decode(match[2]);
})();
if (urlParams["q1"] === 1)
{
return 1;
}
});
</script>
答案 70 :(得分：1)
这将有效...您需要通过传递其名称来调用此函数来获取参数...
function getParameterByName(name)
{
name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
var regexS = "[\\?&]"+name+"=([^&#]*)";
var regex = new RegExp( regexS );
var results = regex.exec( window.location.href );
alert(results[1]);
if (results == null)
return "";
else
return results[1];
}
答案 71 :(得分：1)
可靠地做到这一点比最初想到的更为复杂。
location.search很脆弱
应该避免 - 例如，如果有人拧螺丝，它会返回空
up并在#fragment字符串前加上?query标识符。decodeURIComponent非常强制性
我的意见。要解决此问题，这里有一个可配置的API，其健康剂量为defensive programming。请注意，如果您愿意对某些变量进行硬编码，或者输入永远不会包含hasOwnProperty等，则可以将其缩小一半。
版本1：返回包含每个参数的名称和值的数据对象。它有效地对它们进行了重复删除，并始终尊重从左到右发现的第一个。
function getQueryData(url, paramKey, pairKey, missingValue, decode) {
var query, queryStart, fragStart, pairKeyStart, i, len, name, value, result;
if (!url || typeof url !== 'string') {
url = location.href; // more robust than location.search, which is flaky
}
if (!paramKey || typeof paramKey !== 'string') {
paramKey = '&';
}
if (!pairKey || typeof pairKey !== 'string') {
pairKey = '=';
}
// when you do not explicitly tell the API...
if (arguments.length < 5) {
// it will unescape parameter keys and values by default...
decode = true;
}
queryStart = url.indexOf('?');
if (queryStart >= 0) {
// grab everything after the very first ? question mark...
query = url.substring(queryStart + 1);
} else {
// assume the input is already parameter data...
query = url;
}
// remove fragment identifiers...
fragStart = query.indexOf('#');
if (fragStart >= 0) {
// remove everything after the first # hash mark...
query = query.substring(0, fragStart);
}
// make sure at this point we have enough material to do something useful...
if (query.indexOf(paramKey) >= 0 || query.indexOf(pairKey) >= 0) {
// we no longer need the whole query, so get the parameters...
query = query.split(paramKey);
result = {};
// loop through the parameters...
for (i = 0, len = query.length; i < len; i = i + 1) {
pairKeyStart = query[i].indexOf(pairKey);
if (pairKeyStart >= 0) {
name = query[i].substring(0, pairKeyStart);
} else {
name = query[i];
}
// only continue for non-empty names that we have not seen before...
if (name && !Object.prototype.hasOwnProperty.call(result, name)) {
if (decode) {
// unescape characters with special meaning like ? and #
name = decodeURIComponent(name);
}
if (pairKeyStart >= 0) {
value = query[i].substring(pairKeyStart + 1);
if (value) {
if (decode) {
value = decodeURIComponent(value);
}
} else {
value = missingValue;
}
} else {
value = missingValue;
}
result[name] = value;
}
}
return result;
}
}
版本2：返回一个数据映射对象，该对象具有两个相同长度的数组，一个用于名称，另一个用于值，每个参数都有一个索引。这个支持重复的名称，并且故意不重复它们，因为这可能是你想要使用这种格式的原因。
function getQueryData(url, paramKey, pairKey, missingValue, decode) {
var query, queryStart, fragStart, pairKeyStart, i, len, name, value, result;
if (!url || typeof url !== 'string') {
url = location.href; // more robust than location.search, which is flaky
}
if (!paramKey || typeof paramKey !== 'string') {
paramKey = '&';
}
if (!pairKey || typeof pairKey !== 'string') {
pairKey = '=';
}
// when you do not explicitly tell the API...
if (arguments.length < 5) {
// it will unescape parameter keys and values by default...
decode = true;
}
queryStart = url.indexOf('?');
if (queryStart >= 0) {
// grab everything after the very first ? question mark...
query = url.substring(queryStart + 1);
} else {
// assume the input is already parameter data...
query = url;
}
// remove fragment identifiers...
fragStart = query.indexOf('#');
if (fragStart >= 0) {
// remove everything after the first # hash mark...
query = query.substring(0, fragStart);
}
// make sure at this point we have enough material to do something useful...
if (query.indexOf(paramKey) >= 0 || query.indexOf(pairKey) >= 0) {
// we no longer need the whole query, so get the parameters...
query = query.split(paramKey);
result = {
names: [],
values: []
};
// loop through the parameters...
for (i = 0, len = query.length; i < len; i = i + 1) {
pairKeyStart = query[i].indexOf(pairKey);
if (pairKeyStart >= 0) {
name = query[i].substring(0, pairKeyStart);
} else {
name = query[i];
}
// only continue for non-empty names...
if (name) {
if (decode) {
// unescape characters with special meaning like ? and #
name = decodeURIComponent(name);
}
if (pairKeyStart >= 0) {
value = query[i].substring(pairKeyStart + 1);
if (value) {
if (decode) {
value = decodeURIComponent(value);
}
} else {
value = missingValue;
}
} else {
value = missingValue;
}
result.names.push(name);
result.values.push(value);
}
}
return result;
}
}
答案 72 :(得分：0)
// Parse query string
var params = {}, queryString = location.hash.substring(1),
regex = /([^&=]+)=([^&]*)/g,
m;
while (m = regex.exec(queryString)) {
params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
}