params 订阅
params是一个计算机函数,表示函数的参数是可变个数的,即可变的方法参数,就像DELPHI 里 WRITELN 函数一样,用于表示类型相同,但参数数量不确定。例如,params(int a) 展开全文
params是一个计算机函数,表示函数的参数是可变个数的,即可变的方法参数,就像DELPHI 里 WRITELN 函数一样,用于表示类型相同,但参数数量不确定。例如,params(int a)
信息
领    域
程序开发
类    型
C#开发语言
性    质
关键字
外文名
params
params简介
C#开发语言中 params 是关键字,可以指定在参数数目可变处采用参数的方法参数。在函数的参数数目可变而执行的代码差异很小的时候很有用!在方法声明中的 params 关键字之后不允许任何其他参数,并且在方法声明中只允许一个 params 关键字。关于参数数组,需掌握以下几点。(1)若形参表中含一个参数数组,则该参数数组必须位于形参列表的最后;(2)参数数组必须是一维数组;(3)不允许将params修饰符与ref和out修饰符组合起来使用;(4)与参数数组对应的实参可以是同一类型的数组名,也可以是任意多个与该数组的元素属于同一类型的变量;(5)若实参是数组则按引用传递,若实参是变量或表达式则按值传递。(6)用法:可变的方法参数,也称数组型参数,适合于方法的参数个数不知的情况,用于传递大量的数组集合参数;当使用数组参数时,可通过使用params关键字在形参表中指定多种方法参数,并在方法的参数表中指定一个数组,形式为:方法修饰符 返回类型 方法名(params 类型[] 变量名){方法体}
收起全文
精华内容
下载资源
问答
  • var functionParams = require ( 'function-params' ) ; functionParams ( function ( a , b , /* c */ d , e = 'f' ) ) ; // ['a', 'b', 'd', 'e'] // Arrow functions: functionParams ( a => a ) ; // ['a'] ...
  • 本篇文章主要介绍了详解vue嵌套路由-params传递参数,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 如下: changeList为一个数组 此时请求的参数格式为下图 ...以上这篇在axios中使用params传参的时候传入数组的方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。
  • jquery.params.js

    2017-05-05 09:27:54
    jquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery.params.jsjquery....
  • 如果配置反代不成功,或者SSL反代报错出现跨域问题,请尝试是有本文档的优化配置。 centos7+nginx1.16测试http、https反代均无报错
  • jquery.params.js文件

    2018-10-24 21:09:25
    jquery.params.js文件html和html之间的数据互传,直接调用jquery.params.
  • [removed][removed] [removed][removed] account.jsp?name="+name+"&sex;="+sex; var name = $.query.get("name"); var sex = $.query.get("sex");
  • params

    千次阅读 2019-01-22 19:47:04
    关键字params表示函数的参数是可变个数的,即可变的参数方法 C#: params是关键字,可以指定参数数目可变处采用参数的方法参数。在函数的参数数目可变而执行的代码差异很小的时候很有用。 1.若形参表中含一个参数...

    关键字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. 位置参数 一个最简单的...

    一般最开始接触也就是最简单的函数参数形如 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),意思是,除了namegender这两个参数外,最后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

    为什么要设计strNone这样的不变对象呢?因为不变对象一旦创建,对象内部的数据就不能修改,这样就减少了由于修改数据导致的错误。此外,由于对象不变,多任务环境下同时读取对象不需要加锁,同时读一点问题都没有。我们在编写程序时,如果可以设计一个不变对象,那就尽量设计成不变对象。

    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除了必选参数nameage外,还接受关键字参数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. 命名关键字参数

    如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收cityjob作为关键字参数。和关键字参数**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

     

    展开全文
  • 什么是参数量2 如何计算:参数量,计算量3 对于换算计算量4 对于各个经典网络:5 计算量与参数量对于硬件要求6 计算量(FLOPs)和参数量(Params)第一步:安装模块第二步:计算参考资料 接下来要分别概述以下...

    接下来要分别概述以下内容:

    1 首先什么是参数量,什么是计算量

    2 如何计算 参数量,如何统计 计算量

    3 换算参数量,把他换算成我们常用的单位,比如:mb

    4 对于各个经典网络,论述他们是计算量大还是参数两,有什么好处

    5 计算量,参数量分别对显存,芯片提出什么要求,我们又是怎么权衡
      

    1 首先什么是计算量,什么是参数量

    计算量对应我们之前的时间复杂度,参数量对应于我们之前的空间复杂度,这么说就很明显了

    也就是计算量要看网络执行时间的长短,参数量要看占用显存的量

    2 如何计算:参数量,计算量

    (1)针对于卷积层的
     在这里插入图片描述
    其中上面的公式是计算时间复杂度(计算量),而下面的公式是计算空间复杂度(参数量)

    对于卷积层:

    参数量就是

    (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的计算量
    

    (2)针对于池化层:

    无参数

    (3)针对于全连接层:

    参数量=计算量=weight_in*weight_out
    

    3 对于换算计算量

    • 一般一个参数是值一个float,也就是4个字节

    • 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
    

    参考资料

    1. https://www.cnblogs.com/lllcccddd/p/10671879.html
    2. https://blog.csdn.net/Caesar6666/article/details/109842379
    展开全文
  • HTML 页面跳转时传递参数(jquery....在解析参数页面的 JS 中引入:jquery.params.js(代码贴在本文后面) /** 需要先引入 jquery */ <script type="text/javascript" src="/***/jquery/jquery-3.3.1.min.js...

    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
    
    
    展开全文
  • jquery.params.js下载

    千次下载 热门讨论 2012-10-30 16:06:17
    用于两个HTML网页之间的传值。 a.html?id=i&name=xiaoli; 在b.html页面则可以这样获取: $.query.get("id");
  • python参数*params、**params使用

    千次阅读 2020-03-05 12:46:55
    目录 收集其余的位置参数:*params(输出元组) 收集关键字参数:**params(输出字典) 收集其余的位置参数:*params(输出元组) ...def print_params2(x,*params):#位置参数+收集位置参数...
  • 今天有一个接口是/create?name=***&age=****,但是是一个post请求,我只见过get的这种请求. ...所以你想在第三个参数中发送params对象: .post(`/create`, null, { params: { name:name, age:...
  • 深入了解query和params的使用区别

    千次阅读 2020-07-07 10:53:56
    深入了解query和params的使用区别 这篇文章主要介绍了深入了解query和params的使用区别,路由传参的时候,有俩兄弟,一个叫query,一个叫parmas,你说他们俩长得也不像吧,可这用法实在是太类似了,下面就让我们分别...
  • 前端传递参数params和data的区别

    千次阅读 2021-02-26 01:52:06
    本文学习记录了前端传递参数params和data的区别
  • param和params使用

    千次阅读 2019-07-05 17:01:09
    param和params使用 web页面开发中,经常会有点击查询,查询条件要回显到查询页面,就是点击查询后刷新页面,查询条件要依然存在 这样要满足条件: 服务器响应页面的请求和点击查询的请求是同一个请求,也就是服务器...
  • params详解

    万次阅读 2016-04-13 16:47:14
    或 ...以上二者相同,因为堆跌之后遇见最后一个参数(content或photo)相同时第一个参数自曾([]) ...params中存储的格式相当与 params = {"utf-8"=>"✓", "body" => [{"te
  • tooltip-formatter(params)首先是tooltip格式其次就是分析params参数最后formatter怎么return显示 在做项目的过程中,需要增加点悬浮内容来解释当前点的数据。但是查了echarts和一些资料,说是需要用formatter函数...
  • C# params 用法简介

    万次阅读 多人点赞 2018-07-10 20:45:49
    params 是C#的关键字, 可变长参数,是在声明方法时参数类型或者个数不确定时使用   关于params 参数数组,需掌握以下几点: 一.参数数组必须是一维数组  二.不允许将params修饰符与ref和out修饰符组合起来...
  • methods:{ getDetail(id) { this.$router.push({ name: 'User', params: { id: id } }) } } 对应路由配置 { path: '/user', name: 'User', component: User } 子组件获取参数 this.$route.params.id 3、使用路由...
  • 接口请求时params与data的区别

    千次阅读 2020-08-12 16:53:19
    GET请求时,使用params,参数会直接追加至请求字符串(url)后,可以在Postman中测试; axios({ method: "get", url: "http://www.tuling123.com/openapi/api", params: { info: "BJ" }, }) POST请求时,...
  • vue中params和query的区别,以及具体用法

    千次阅读 多人点赞 2020-07-22 10:22:21
    params传递参数不会显示在页面中;query有点像ajax中的get请求,而params像post请求。 在vue中使用query要搭配path路径,而params只能由命名路由name来引入;看下列代码: 路由中path的配置 { path: '/argu/:...
  • 有时候我们在使用别人的mxnet预训练模型时,会有两个文件params和json文件,其中params文件中包含的是模型的网络参数,json文件包含的是网络的结构。这里我们以ImageNet的预训练模型为例,来介绍如何加载模型并进行...
  • Postman的Params传参和body传参的区别

    万次阅读 2020-03-04 22:21:14
    我相信很多人都很迷惑postman工具的params和body两个地方传递参数的区别,到底放那里? 谜底揭晓:Params处设置的变量请求时会url后问好传参。而Body里设置的参数则是接口真正请求时发的参数。 ...
  • vue中使用post请求传递params参数

    千次阅读 2021-04-16 17:49:13
    使用post请求时,通常只包含body的数据,但http协议并没有规定post协议不能传params参数,这就意味着一个post请求同时可以包含params和body两部分数据。在传递两部分参数时,一定要注意,body部分一定要转成字符串...
  • Vue params 和 query 传参的 区别

    千次阅读 2018-11-28 11:01:12
    今天我们就来说一下params和query传参的使用和区别,要说这个的话,我们就有必要提一下Vue-router了。 Vue-router它主要分为动态路由(传参匹配的问题),嵌套路由(父子组件之间的通信),编程式路由(this.$router...
  • 一般项目都会有一些逻辑需要传递值给另一个页面,...1、通过路由传值,params或query 2、通过vuex进行状态管理 $store.state... 3、使用localStorage进行传值 那么,关于刷新页面数据消失原因有两种,一是通过...
  • Vue Router 的params和query传参的使用和区别(详尽)

    万次阅读 多人点赞 2018-08-22 15:38:51
    首先简单来说明一下$router和$route的区别 //$router : 是路由操作对象,只写对象 //$route : 路由信息对象,只读对象 //操作 路由跳转 ... params:{ name:'word', age:'11' } }) //读取 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 673,786
精华内容 269,514
关键字:

params