根据我的理解,在Scala中,函数也可以被调用
传递或 的名字
例如,给定以下声明,我们是否知道函数将如何被调用?
声明:
def f (x:Int, y:Int) = x;
Call
f (1,2)
f (23+55,5)
f (12+3, 44*11)
请问规则是什么?
根据我的理解,在Scala中,函数也可以被调用
传递或 的名字
例如,给定以下声明,我们是否知道函数将如何被调用?
声明:
def f (x:Int, y:Int) = x;
Call
f (1,2)
f (23+55,5)
f (12+3, 44*11)
请问规则是什么?
当前回答
我不认为这里所有的答案都是正确的:
在按值调用中,参数只计算一次:
def f(x : Int, y :Int) = x
// following the substitution model
f(12 + 3, 4 * 11)
f(15, 4194304)
15
你可以在上面看到,不管是否需要,所有的参数都会被求值,通常按值调用可以很快,但并不总是像这种情况。
如果评估策略是按名称调用的,那么分解将是:
f(12 + 3, 4 * 11)
12 + 3
15
正如你所看到的,我们从来不需要计算4 * 11,因此节省了一些计算,这有时可能是有益的。
其他回答
您给出的示例只使用了按值调用,因此我将给出一个新的、更简单的示例来显示两者的区别。
首先,让我们假设我们有一个带有副作用的函数。这个函数输出一些内容,然后返回一个Int型。
def something() = {
println("calling something")
1 // return value
}
现在我们将定义两个函数,它们接受完全相同的Int参数,除了一个以值调用风格(x: Int)接受参数,另一个以名称调用风格(x: => Int)接受参数。
def callByValue(x: Int) = {
println("x1=" + x)
println("x2=" + x)
}
def callByName(x: => Int) = {
println("x1=" + x)
println("x2=" + x)
}
当我们用副作用函数调用它们时会发生什么?
scala> callByValue(something())
calling something
x1=1
x2=1
scala> callByName(something())
calling something
x1=1
calling something
x2=1
因此,您可以看到,在按值调用版本中,传入函数调用(something())的副作用只发生了一次。然而,在叫名字的版本中,副作用发生了两次。
这是因为按值调用函数在调用函数之前会计算传入表达式的值,因此每次都会访问相同的值。相反,每次访问传入表达式时,名称调用函数都会重新计算传入表达式的值。
CallByName在使用时被调用,callByValue在遇到语句时被调用。
例如:-
我有一个无限循环,即如果你执行这个函数,我们将永远不会得到scala提示。
scala> def loop(x:Int) :Int = loop(x-1)
loop: (x: Int)Int
callByName函数接受上述循环方法作为参数,并且从不在函数体中使用。
scala> def callByName(x:Int,y: => Int)=x
callByName: (x: Int, y: => Int)Int
在callByName方法的执行中,我们没有发现任何问题(我们得到scala提示返回),因为我们没有在callByName函数中使用循环函数。
scala> callByName(1,loop(10))
res1: Int = 1
scala>
callByValue函数将上述循环方法作为参数,因为函数内部的结果或表达式在执行外部函数之前被递归执行的循环函数求值,并且我们永远不会得到scala提示。
scala> def callByValue(x:Int,y:Int) = x
callByValue: (x: Int, y: Int)Int
scala> callByValue(1,loop(1))
为了重复@Ben在上面评论中的观点,我认为最好将“按名字称呼”视为语法糖。解析器只是将表达式包装在匿名函数中,以便稍后在使用它们时调用它们。
实际上,不是定义
def callByName(x: => Int) = {
println("x1=" + x)
println("x2=" + x)
}
并运行:
scala> callByName(something())
calling something
x1=1
calling something
x2=1
你也可以这样写:
def callAlsoByName(x: () => Int) = {
println("x1=" + x())
println("x2=" + x())
}
并运行它,以达到同样的效果:
callAlsoByName(() => {something()})
calling something
x1=1
calling something
x2=1
正如我假设的那样,上面讨论的按值调用函数只是将值传递给函数。根据Martin Odersky的说法,这是Scala遵循的一种评估策略,在函数评估中扮演着重要的角色。但是,让叫名字变得简单。这就像将函数作为参数传递给方法(也称为高阶函数)。当方法访问传递参数的值时,它调用传递函数的实现。如下:
根据@dhg示例,首先创建方法如下:
def something() = {
println("calling something")
1 // return value
}
这个函数包含一个println语句并返回一个整数值。创建函数,其参数为call-by-name:
def callByName(x: => Int) = {
println("x1=" + x)
println("x2=" + x)
}
此函数参数定义了一个匿名函数,返回一个整数值。在这个x中包含一个函数的定义,它传递0个参数,但返回int值,我们的something函数包含相同的签名。调用函数时,将函数作为参数传递给callByName。但在按值调用的情况下,它只将整数值传递给函数。我们将函数调用如下:
scala> callByName(something())
calling something
x1=1
calling something
x2=1
在这里,我们的something方法调用了两次,因为当我们在callByName方法中访问x的值时,它调用了something方法的定义。
参数通常是按值传递的,这意味着它们在被替换到函数体之前会被求值。
在定义函数时,可以使用双箭头强制按名称调用参数。
// first parameter will be call by value, second call by name, using `=>`
def returnOne(x: Int, y: => Int): Int = 1
// to demonstrate the benefits of call by name, create an infinite recursion
def loop(x: Int): Int = loop(x)
// will return one, since `loop(2)` is passed by name so no evaluated
returnOne(2, loop(2))
// will not terminate, since loop(2) will evaluate.
returnOne(loop(2), 2) // -> returnOne(loop(2), 2) -> returnOne(loop(2), 2) -> ...