标签: arguments

是否可以*args从变量设置？

def fn(x, *args):
    # ...

# pass arguments not as list but each as single argument
arguments = ??? # i.e.: ['a', 'b']


fn(1, arguments)

# should be equivalent to
fn(1, 'a', 'b')

我写了一些代码:

#include <stdlib.h>
#include <stdio.h>

    int a_function(int *a, int a_length, int *returned_address)
    {
        returned_address=a+a_length-1;
        return 0;
    }

    int main(void)
    {
        int n=5;
        int *a;
        int *address=NULL;
        a=(int*)malloc(n*sizeof(*a));
        a_function(a,n,address);
        printf("%p",address);
        return 0;
    }

预期的结果是指针'地址'指向a + 4地址处的内存块.但结果是指针"地址"仍指向NULL(屏幕上的打印结果类似于'00000000').但是,当我开始调试时,在'a_function'中,'returned_address'确实指向了+ 4的内存块.我错过了什么？

我总是得到消息,我的数组中的参数不是nummeric.它在这个小代码中发生了5次:

    my $mcnamequery = "SELECT mcID FROM tblMCName WHERE mcName = '".$mcname."'";
$mcid = dbSelect($mcnamequery);
print $mcid->{mcID} . "\n";

my $userfsquery = "SELECT userFS FROM tblMcSubs WHERE mcFS = '".$mcid->{mcID}."'";  
my $execute = $dbh->prepare($userfsquery);
$execute->execute();

while (@usersfs = $execute->fetchrow_array()) {
    print $usersfs['userFS'] . "\n";

    my $mailquery = "SELECT useremail FROM tblUser WHERE userID = '".$usersfs['userFS']."'";
    $execute2 = $dbh->prepare($mailquery);
    $execute2->execute();
    while (@mails = $execute2->fetchrow_array()) {
        $counter++;
        print $mails['useremail']. "\n";
        if($counter == 1){
                $addresses = $mails['useremail'];
        }else{
            $addresses = $addresses. " " …

假设我要输出的方法的东西,在这种情况下,字符串或整数.我可以这样做:

def outString(str: String) {
    str // or "return str"
}

并像这样运行: outString("foo")

但我也可以避免将特定类型初始化为参数,它会起作用:

def outString(str: Any) {
    str
}

并运行它像这样:outString("foo")或outString(123).

鉴于它们都工作并假设你并不总是知道所传递的Any参数的类型,使用特定参数类型是否有任何陷阱？是否Any做检查类似解释的语言也将减缓对代码进行任何类型的自动型的？

我有一个包含五个键的键值对,其值为每个千位对象的巨大数组.我可以在将它传递给函数时将其子集化,或者我可以在函数中传递整个数组.

例如:

keyVal ={"first_array": Object[1000],
"second_array": Object[1000],
"third_array": Object[1000],
"fourth_array": Object[1000]
}
var first_arr = keyVal.first_array

两种可能性:

function notSubsettedArgs(keyVal){
$.each(keyVal.first_array,function(i,item){
//some processing});
}

function subsettedArgs(first_array){
$.each(first_array,function(i,item){
//do some processing});
}

它在javascript中有所不同吗？
函数是否承担参数大小的负载？
谢谢

在本声明的最后:

let (a,b,c) = (1,2,3) in printfn "%i,%i" a b;;

, 有

a b;;

结尾"a"和"b"的用法是什么,它们是某些函数调用的参数,还是它们是前一个函数的返回值(元组)？如果是这样,let(a,b,c)的用法是什么,我想它应该定义一个由3个元素组成的元组,但是printfn在语句中做了什么？

换句话说,我如何将这个复杂的语句拆分成几个更容易理解的简短语句？我不退出得到"让......进入"语义.有什么解释吗？

谢谢.

我发现C#的这个功能"命名参数"真的很奇怪,因为我看到了它的两个缺陷.该书说"命名参数赋予你"以任何顺序传递参数的能力".

我认为这个C#功能存在两个缺陷:

1. 它违反了计算机科学中的"信息隐藏".(即:使用该方法的最终用户需要知道参数名称和数据类型才能使用该功能.)来自Java背景,这很奇怪.为什么要将参数名称暴露给用户的末尾？

2. 它容易产生歧义,可能导致错误.(当程序员编写使用相同方法名称(也称为重载方法)的方法时,程序员需要进行额外的思考和问题.当你有两个同名的方法时,你总会得到一个"调用是不明确的"即使另一个方法具有不同数据类型的额外参数,彼此具有相同的参数.我能想到的唯一修复是使数据类型成为"强制参数",也就是没有默认值的参数,因此编译器会不要混淆.但是这个修复只是一个导致另一个最坏情况的绷带解决方案(见下文)

业内人士甚至在今天都使用这个概念吗？如果是这样,为什么要打破这两条规则"在调用方法时以任何顺序传递参数的能力"？

TLDR:通过引入可能的最坏情况场景(编译器选择了错误的方法调用......尽管两种方法相似)来清楚地说明我所说的内容:

namespace ConsoleApplication1
{
    class Venusaur
    {
        static void Main(string[] args)
        {

            new Venusaur().optMethod(fourth: "s");
        }

        public void optMethod(  string third , string fourth =  "hello", int fifth = 23, string two = "w")
        {
            // what if I wanted this method to run instead of the method below me
            Console.WriteLine("did not execute");
        }


        public void optMethod(string third = "Byte", string fourth = "hello",  int fifth = 4)
        {
            // But this method ran instead …

我不明白参数和参数之间的连接或区别.你能用这两种方法吗？你怎么回答论点？任何帮助是极大的赞赏.

考虑一个矩形和一个正方形.如果我们将它们视为对象,很明显,正方形可以从矩形继承其大部分或全部属性,因为正方形是矩形的特殊情况.唯一的限制是正方形必须具有相似的边长.

看看这个非常基本的实现.

class Rectangle(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def get_area(self):
        return self.x * self.y


class Square(Rectangle):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if self.x != self.y:
            raise ValueError("x and y must be equal.")

为简单起见,避免了类型检查.我使用args并且kwargs为了确保子类将是未来证明.但是,我不确定我是否正确行事.Rectangleclass' __init__可能会在将来添加更多参数.

问题是,如果x和y必须相等,为什么要首先要求它们？难道不应该只有一个吗？当前的继承方案有这个限制 - 用户被迫输入x和y.怎样才能解决这个问题.将x和y转换为关键字参数不是解决方案,因为不允许使用默认值(或None).

我有下面的代码.如果您将代码传递给列表,它将提供该位置的值(它是零索引).这段代码有效,但如果我用count ++替换count = count + 1(在条件的最后一个分支中),它就不再起作用了.有人可以帮我理解为什么吗？

注意:如果您调用此函数:

var list = {value: 10, rest: {value: 10, rest: {value: 30, rest: null}}}

nth(list, 1)

输出应为20.

function nth(list, index, count) {
    if (count === undefined) {
        count = 0;
    }

    if (count === index) {
        return list.value;
    }
    else if (list.rest === null) {
        return undefined;
    }
    else {
        // note that count++ will not work here
        return nth(list.rest, index, count = count + 1);
    }
}