关键字params表示函数的参数是可变个数的，即可变的参数方法
 
 
C#:
  params是关键字，可以指定参数数目可变处采用参数的方法参数。在函数的参数数目可变而执行的代码差异很小的时候很有用。
  1.若形参表中含一个参数数组，则该参数数组必须位于形参列表的最后面；
  2.参数数组必须是一维数组；
  3.不允许将params修饰符与re和out修饰符组合起来使用；
  4.与参数数组 对应的实参可以是同一类型的数组名，也可以是任意多个与该数组的元素属于同一类型的变量；
  5.若实数是数组则按引用传递，若实参是变量或表达式则按值传递；
  6.用法：
    可变的方法参数，也称数组型参数，适合于方法的参数个数不知的情况，用于传递大量的数组集合参数；
    当使用数组参数时，可通过使用params关键字在形参中在指定多种方法参数，并在方法参数中指定一个数组，
    形式：方法修饰符返回类型方法名（params类型变量名）
    {
    方法体;
    }
 
python:
requests.get(url,params=None,**kwargs)
url:拟获取页面URL链接
params：URL中额外参数，字典或字节流格式，可选
**kwargs:12个控制访问的参数

一般最开始接触也就是最简单的函数参数形如 def fuc(x) ,但是也有复杂的函数参数传递方式，总结一下python的传参方式，先介绍一下参数的基本类型，最后讲到最复杂的（**params）类型。
 
1. 位置参数
 
一个最简单的函数形式，其中x,y就是位置参数： 
 
def add_both(x, y):
    return x+y
 
2. 默认参数
 
最大的好处是能降低调用函数的难度；
必选参数在前，默认参数在后，否则Python的解释器会报错；
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
 
有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。
 
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。
 
 
 
默认参数的坑：
 
 
def add_end(L=[]):
    L.append('END')
    return L
 
 
连续调用默认参数调用add_end()，默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list，
 
 
原因解释如下：
 
 
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
 
 
>>> add_end()
['END']
>>> add_end()
['END', 'END']
 
 
定义默认参数要牢记一点：默认参数必须指向不变对象，这也是为什么大多数函数默认参数都是None；
 
 
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L
 
 
为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
 
 
3. 可变参数
 
可变参数就是传入的参数个数是可变的，可以是任意个。
 
类似最常见的情况就是传入的参数是list或者tuple，运用在循环里：
 
def cal_num(nums):
    for i in nums:
        print(i)
 
>>> cal_num([1, 2])
1
2
 
而定义可变参数就是在参数前加一个*号，改为可变参数；参数nums接收到的是一个tuple，函数代码完全不变。调用函数的时候传入任意个参数，包括0个；
 
def cal_num(*nums):
    for i in nums:
        print(i)
 
>>> cal_num(1, 2)
1
2
 
如果已经有一个list或者tuple，要调用一个可变参数怎么办？Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去; *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
 
>>> nums = [1, 2]
>>> cal_num(*nums)
1
2
 
4. 关键字参数
 
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
 
函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数，也可以传入任意个数的关键字参数：
 
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
 
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
 
4. 命名关键字参数
 
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
 
def person(name, age, *, city, job):
    print(name, age, city, job)
 
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
 
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。
 
def person(name, age, *args, city, job):
    print(name, age, args, city, job)
 
 
 
 
 
 
 
 
 
参考链接：https://www.liaoxuefeng.com/wiki/1016959663602400/1017261630425888
 
 

接下来要分别概述以下内容：
 
１　首先什么是参数量，什么是计算量
 
２　如何计算　参数量，如何统计　计算量
 
３　换算参数量，把他换算成我们常用的单位，比如:mb
 
４　对于各个经典网络，论述他们是计算量大还是参数两，有什么好处
 
５　计算量，参数量分别对显存，芯片提出什么要求，我们又是怎么权衡
 　　
 

 
深度学习中模型参数量和计算量的理解与计算
 
1 首先什么是计算量，什么是参数量
2 如何计算：参数量，计算量
3 对于换算计算量
4 对于各个经典网络：
5 计算量与参数量对于硬件要求
6 计算量(FLOPs)和参数量(Params)
6.1 第一种方法：thop
第一步：安装模块
第二步：计算
   
6.2 第二种方法：ptflops
6.3 第三种方法：pytorch_model_summary
6.4 第四种方法：参数总量和可训练参数总量
  
参考资料

 
1 首先什么是计算量，什么是参数量
 
计算量对应我们之前的时间复杂度，参数量对应于我们之前的空间复杂度，这么说就很明显了
 
也就是计算量要看网络执行时间的长短，参数量要看占用显存的量
 
2 如何计算：参数量，计算量
 
（１）针对于卷积层的
 　
 其中上面的公式是计算时间复杂度(计算量)，而下面的公式是计算空间复杂度(参数量)
 
对于卷积层：
 
参数量就是
 
(kernel*kernel) *channel_input*channel_output

kernel*kernel 就是 weight * weight

其中kernel*kernel ＝ 1个feature的参数量
 
计算量就是
 
(kernel*kernel*map*map) *channel_input*channel_output

kernel*kernel 就是weight*weight

map*map是下个featuremap的大小，也就是上个weight*weight到底做了多少次运算

其中kernel*kernel*map*map＝　1个feature的计算量
 
（２）针对于池化层：
 
无参数
 
（３）针对于全连接层：
 
参数量＝计算量＝weight_in*weight_out
 
3 对于换算计算量
 
 
一般一个参数是值一个float，也就是４个字节
 
 
1kb=1024字节
 
 
4 对于各个经典网络：
 

 (1)换算
 
以alexnet为例：
 
参数量：6000万
 
设每个参数都是float,也就是一个参数是4字节，
 
总的字节数是24000万字节
 
24000万字节= 24000万/1024/1024=228mb
 
(2)为什么模型之间差距这么大
 
这个关乎于模型的设计了，其中模型里面最费参数的就是全连接层，这个可以看alex和vgg,
 
alex,vgg有很多fc(全连接层)
 
resnet就一个fc
 
inceptionv1(googlenet)也是就一个fc
 
(3)计算量
 
densenet其实这个模型不大，也就是参数量不大，因为就1个fc
 
但是他的计算量确实很大，因为每一次都把上一个feature加进来，所以计算量真的很大
 
5 计算量与参数量对于硬件要求
 
计算量，参数量对于硬件的要求是不同的
 
计算量的要求是在于芯片的floaps（指的是gpu的运算能力）
 
参数量取决于显存大小
 
6 计算量(FLOPs)和参数量(Params)
 
6.1 第一种方法：thop
 
计算量：
 FLOPs，FLOP时指浮点运算次数，s是指秒，即每秒浮点运算次数的意思，考量一个网络模型的计算量的标准。
 
参数量：
 Params，是指网络模型中需要训练的参数总数。
 
第一步：安装模块
 
pip install thop
 
第二步：计算
 
# -- coding: utf-8 --
import torch
import torchvision
from thop import profile

# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)

dummy_input = torch.randn(1, 3, 224, 224)
flops, params = profile(model, (dummy_input,))
print('flops: ', flops, 'params: ', params)
print('flops: %.2f M, params: %.2f M' % (flops / 1000000.0, params / 1000000.0))
 
结果
 
==> Building model..
[INFO] Register count_convNd() for <class 'torch.nn.modules.conv.Conv2d'>.
[INFO] Register zero_ops() for <class 'torch.nn.modules.activation.ReLU'>.
[INFO] Register zero_ops() for <class 'torch.nn.modules.pooling.MaxPool2d'>.
[WARN] Cannot find rule for <class 'torch.nn.modules.container.Sequential'>. Treat it as zero Macs and zero Params.
[INFO] Register count_adap_avgpool() for <class 'torch.nn.modules.pooling.AdaptiveAvgPool2d'>.
[INFO] Register zero_ops() for <class 'torch.nn.modules.dropout.Dropout'>.
[INFO] Register count_linear() for <class 'torch.nn.modules.linear.Linear'>.
[WARN] Cannot find rule for <class 'torchvision.models.alexnet.AlexNet'>. Treat it as zero Macs and zero Params.
flops:  714691904.0 params:  61100840.0
flops: 714.69 M, params: 61.10 M

 
注意：
 
输入input的第一维度是批量(batch size)，批量的大小不回影响参数量， 计算量是batch_size=1的倍数
profile(net, (inputs,))的 (inputs,)中必须加上逗号，否者会报错
 
6.2 第二种方法：ptflops
 
# -- coding: utf-8 --
import torchvision
from ptflops import get_model_complexity_info

model = torchvision.models.alexnet(pretrained=False)
flops, params = get_model_complexity_info(model, (3, 224, 224), as_strings=True, print_per_layer_stat=True)
print('flops: ', flops, 'params: ', params)

 
结果
 
AlexNet(
  61.101 M, 100.000% Params, 0.716 GMac, 100.000% MACs, 
  (features): Sequential(
    2.47 M, 4.042% Params, 0.657 GMac, 91.804% MACs, 
    (0): Conv2d(0.023 M, 0.038% Params, 0.07 GMac, 9.848% MACs, 3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.027% MACs, inplace=True)
    (2): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.027% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(0.307 M, 0.503% Params, 0.224 GMac, 31.316% MACs, 64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.020% MACs, inplace=True)
    (5): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.020% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(0.664 M, 1.087% Params, 0.112 GMac, 15.681% MACs, 192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.009% MACs, inplace=True)
    (8): Conv2d(0.885 M, 1.448% Params, 0.15 GMac, 20.902% MACs, 384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)
    (10): Conv2d(0.59 M, 0.966% Params, 0.1 GMac, 13.936% MACs, 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, inplace=True)
    (12): MaxPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.006% MACs, kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, output_size=(6, 6))
  (classifier): Sequential(
    58.631 M, 95.958% Params, 0.059 GMac, 8.195% MACs, 
    (0): Dropout(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, p=0.5, inplace=False)
    (1): Linear(37.753 M, 61.788% Params, 0.038 GMac, 5.276% MACs, in_features=9216, out_features=4096, bias=True)
    (2): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)
    (3): Dropout(0.0 M, 0.000% Params, 0.0 GMac, 0.000% MACs, p=0.5, inplace=False)
    (4): Linear(16.781 M, 27.465% Params, 0.017 GMac, 2.345% MACs, in_features=4096, out_features=4096, bias=True)
    (5): ReLU(0.0 M, 0.000% Params, 0.0 GMac, 0.001% MACs, inplace=True)
    (6): Linear(4.097 M, 6.705% Params, 0.004 GMac, 0.573% MACs, in_features=4096, out_features=1000, bias=True)
  )
)
flops:  0.72 GMac params:  61.1 M
 
6.3 第三种方法：pytorch_model_summary
 
import torch
import torchvision
from pytorch_model_summary import summary

# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)

dummy_input = torch.randn(1, 3, 224, 224)
print(summary(model, dummy_input, show_input=False, show_hierarchical=False))
 
结果
 
==> Building model..
-----------------------------------------------------------------------------
           Layer (type)         Output Shape         Param #     Tr. Param #
=============================================================================
               Conv2d-1      [1, 64, 55, 55]          23,296          23,296
                 ReLU-2      [1, 64, 55, 55]               0               0
            MaxPool2d-3      [1, 64, 27, 27]               0               0
               Conv2d-4     [1, 192, 27, 27]         307,392         307,392
                 ReLU-5     [1, 192, 27, 27]               0               0
            MaxPool2d-6     [1, 192, 13, 13]               0               0
               Conv2d-7     [1, 384, 13, 13]         663,936         663,936
                 ReLU-8     [1, 384, 13, 13]               0               0
               Conv2d-9     [1, 256, 13, 13]         884,992         884,992
                ReLU-10     [1, 256, 13, 13]               0               0
              Conv2d-11     [1, 256, 13, 13]         590,080         590,080
                ReLU-12     [1, 256, 13, 13]               0               0
           MaxPool2d-13       [1, 256, 6, 6]               0               0
   AdaptiveAvgPool2d-14       [1, 256, 6, 6]               0               0
             Dropout-15            [1, 9216]               0               0
              Linear-16            [1, 4096]      37,752,832      37,752,832
                ReLU-17            [1, 4096]               0               0
             Dropout-18            [1, 4096]               0               0
              Linear-19            [1, 4096]      16,781,312      16,781,312
                ReLU-20            [1, 4096]               0               0
              Linear-21            [1, 1000]       4,097,000       4,097,000
=============================================================================
Total params: 61,100,840
Trainable params: 61,100,840
Non-trainable params: 0
-----------------------------------------------------------------------------
 
6.4 第四种方法：参数总量和可训练参数总量
 
import torch
import torchvision
from pytorch_model_summary import summary

# Model
print('==> Building model..')
model = torchvision.models.alexnet(pretrained=False)

pytorch_total_params = sum(p.numel() for p in model.parameters())
trainable_pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)

print('Total - ', pytorch_total_params)
print('Trainable - ', trainable_pytorch_total_params)
 
结果
 
==> Building model..
Total -  61100840
Trainable -  61100840
 
参考资料
 
https://www.cnblogs.com/lllcccddd/p/10671879.html
https://blog.csdn.net/Caesar6666/article/details/109842379

HTML 页面跳转时传递参数（jquery.params.js）
 
描述：在 HTML 页面跳转时，通过 URL 传递参数
 
一、引入
 
在解析参数页面的 JS 中引入：jquery.params.js（代码贴在本文后面）
 
/**
	需要先引入 jquery
*/
<script type="text/javascript" src="/***/jquery/jquery-3.3.1.min.js"></script>
<script type="text/javascript" src="/***/jquery-params/jquery.params.js"></script>
 
二、使用
 
请求：
 
http://localhost.com/***/detail.html?noticeId=14134
 
JS 解析
 
$(function () {
    getParamData();
});

function getParamData() {
    var noticeId = $.query.get("noticeId");
    alert(noticeId);
}
 
jquery.params.js 源码
 
新建个文件，拷贝即可
 
/**
* jQuery.query - Query String Modification and Creation for jQuery
* Written by Blair Mitchelmore (blair DOT mitchelmore AT gmail DOT com)
* Licensed under the WTFPL (http://sam.zoy.org/wtfpl/).
* Date: 2009/8/13
*
* @author Blair Mitchelmore
* @version 2.1.7
*
**/
new function (settings) {
    // Various Settings
    var $separator = settings.separator || '&';
    var $spaces = settings.spaces === false ? false : true;
    var $suffix = settings.suffix === false ? '' : '[]';
    var $prefix = settings.prefix === false ? false : true;
    var $hash = $prefix ? settings.hash === true ? "#" : "?" : "";
    var $numbers = settings.numbers === false ? false : true;

    jQuery.query = new function () {
        var is = function (o, t) {
            return o != undefined && o !== null && (!!t ? o.constructor == t : true);
        };
        var parse = function (path) {
            var m, rx = /\[([^[]*)\]/g, match = /^([^[]+)(\[.*\])?$/.exec(path), base = match[1], tokens = [];
            while (m = rx.exec(match[2])) tokens.push(m[1]);
            return [base, tokens];
        };
        var set = function (target, tokens, value) {
            var o, token = tokens.shift();
            if (typeof target != 'object') target = null;
            if (token === "") {
                if (!target) target = [];
                if (is(target, Array)) {
                    target.push(tokens.length == 0 ? value : set(null, tokens.slice(0), value));
                } else if (is(target, Object)) {
                    var i = 0;
                    while (target[i++] != null);
                    target[--i] = tokens.length == 0 ? value : set(target[i], tokens.slice(0), value);
                } else {
                    target = [];
                    target.push(tokens.length == 0 ? value : set(null, tokens.slice(0), value));
                }
            } else if (token && token.match(/^\s*[0-9]+\s*$/)) {
                var index = parseInt(token, 10);
                if (!target) target = [];
                target[index] = tokens.length == 0 ? value : set(target[index], tokens.slice(0), value);
            } else if (token) {
                var index = token.replace(/^\s*|\s*$/g, "");
                if (!target) target = {};
                if (is(target, Array)) {
                    var temp = {};
                    for (var i = 0; i < target.length; ++i) {
                        temp[i] = target[i];
                    }
                    target = temp;
                }
                target[index] = tokens.length == 0 ? value : set(target[index], tokens.slice(0), value);
            } else {
                return value;
            }
            return target;
        };

        var queryObject = function (a) {
            var self = this;
            self.keys = {};

            if (a.queryObject) {
                jQuery.each(a.get(), function (key, val) {
                    self.SET(key, val);
                });
            } else {
                jQuery.each(arguments, function () {
                    var q = "" + this;
                    q = q.replace(/^[?#]/, ''); // remove any leading ? || #
                    q = q.replace(/[;&]$/, ''); // remove any trailing & || ;
                    if ($spaces) q = q.replace(/[+]/g, ' '); // replace +'s with spaces

                    jQuery.each(q.split(/[&;]/), function () {
                        var key = decodeURIComponent(this.split('=')[0] || "");
                        var val = decodeURIComponent(this.split('=')[1] || "");

                        if (!key) return;

                        if ($numbers) {
                            if (/^[+-]?[0-9]+\.[0-9]*$/.test(val)) // simple float regex
                                val = parseFloat(val);
                            else if (/^[+-]?[0-9]+$/.test(val)) // simple int regex
                                val = parseInt(val, 10);
                        }

                        val = (!val && val !== 0) ? true : val;

                        if (val !== false && val !== true && typeof val != 'number')
                            val = val;

                        self.SET(key, val);
                    });
                });
            }
            return self;
        };

        queryObject.prototype = {
            queryObject: true,
            has: function (key, type) {
                var value = this.get(key);
                return is(value, type);
            },
            GET: function (key) {
                if (!is(key)) return this.keys;
                var parsed = parse(key), base = parsed[0], tokens = parsed[1];
                var target = this.keys[base];
                while (target != null && tokens.length != 0) {
                    target = target[tokens.shift()];
                }
                return typeof target == 'number' ? target : target || "";
            },
            get: function (key) {
                var target = this.GET(key);
                if (is(target, Object))
                    return jQuery.extend(true, {}, target);
                else if (is(target, Array))
                    return target.slice(0);
                return target;
            },
            SET: function (key, val) {
                var value = !is(val) ? null : val;
                var parsed = parse(key), base = parsed[0], tokens = parsed[1];
                var target = this.keys[base];
                this.keys[base] = set(target, tokens.slice(0), value);
                return this;
            },
            set: function (key, val) {
                return this.copy().SET(key, val);
            },
            REMOVE: function (key) {
                return this.SET(key, null).COMPACT();
            },
            remove: function (key) {
                return this.copy().REMOVE(key);
            },
            EMPTY: function () {
                var self = this;
                jQuery.each(self.keys, function (key, value) {
                    delete self.keys[key];
                });
                return self;
            },
            load: function (url) {
                var hash = url.replace(/^.*?[#](.+?)(?:\?.+)?$/, "$1");
                var search = url.replace(/^.*?[?](.+?)(?:#.+)?$/, "$1");
                return new queryObject(url.length == search.length ? '' : search, url.length == hash.length ? '' : hash);
            },
            empty: function () {
                return this.copy().EMPTY();
            },
            copy: function () {
                return new queryObject(this);
            },
            COMPACT: function () {
                function build(orig) {
                    var obj = typeof orig == "object" ? is(orig, Array) ? [] : {} : orig;
                    if (typeof orig == 'object') {
                        function add(o, key, value) {
                            if (is(o, Array))
                                o.push(value);
                            else
                                o[key] = value;
                        }
                        jQuery.each(orig, function (key, value) {
                            if (!is(value)) return true;
                            add(obj, key, build(value));
                        });
                    }
                    return obj;
                }
                this.keys = build(this.keys);
                return this;
            },
            compact: function () {
                return this.copy().COMPACT();
            },
            toString: function () {
                var i = 0, queryString = [], chunks = [], self = this;
                var encode = function (str) {
                    str = str + "";
                    if ($spaces) str = str.replace(/ /g, "+");
                    return encodeURIComponent(str);
                };
                var addFields = function (arr, key, value) {
                    if (!is(value) || value === false) return;
                    var o = [encode(key)];
                    if (value !== true) {
                        o.push("=");
                        o.push(encode(value));
                    }
                    arr.push(o.join(""));
                };
                var build = function (obj, base) {
                    var newKey = function (key) {
                        return !base || base == "" ? [key].join("") : [base, "[", key, "]"].join("");
                    };
                    jQuery.each(obj, function (key, value) {
                        if (typeof value == 'object')
                            build(value, newKey(key));
                        else
                            addFields(chunks, newKey(key), value);
                    });
                };

                build(this.keys);

                if (chunks.length > 0) queryString.push($hash);
                queryString.push(chunks.join($separator));

                return queryString.join("");
            }
        };

        return new queryObject(location.search, location.hash);
    };
} (jQuery.query || {}); // Pass in jQuery.query as settings object