您给出的示例只使用了按值调用，因此我将给出一个新的、更简单的示例来显示两者的区别。

首先，让我们假设我们有一个带有副作用的函数。这个函数输出一些内容，然后返回一个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())的副作用只发生了一次。然而，在叫名字的版本中，副作用发生了两次。

这是因为按值调用函数在调用函数之前会计算传入表达式的值，因此每次都会访问相同的值。相反，每次访问传入表达式时，名称调用函数都会重新计算传入表达式的值。

下面是我编写的一个快速示例，以帮助我的一位正在学习Scala课程的同事。我觉得有趣的是，Martin没有使用之前在讲座中提到的&&问题的答案作为例子。无论如何，我希望这能有所帮助。

val start = Instant.now().toEpochMilli

val calc = (x: Boolean) => {
    Thread.sleep(3000)
    x
}


def callByValue(x: Boolean, y: Boolean): Boolean = {
    if (!x) x else y
}

def callByName(x: Boolean, y: => Boolean): Boolean = {
    if (!x) x else y
}

new Thread(() => {
    println("========================")
    println("Call by Value " + callByValue(false, calc(true)))
    println("Time " + (Instant.now().toEpochMilli - start) + "ms")
    println("========================")
}).start()


new Thread(() => {
    println("========================")
    println("Call by Name " + callByName(false, calc(true)))
    println("Time " + (Instant.now().toEpochMilli - start) + "ms")
    println("========================")
}).start()


Thread.sleep(5000)

代码的输出如下:

========================
Call by Name false
Time 64ms
========================
Call by Value false
Time 3068ms
========================

在按值调用中，表达式的值是在函数调用时预先计算的，并且该特定值作为参数传递给相应的函数。相同的值将在整个函数中使用。

而在名称调用中，表达式本身作为参数传递给函数，并且仅在调用特定参数时在函数内部计算。

Scala中按名称调用和按值调用之间的区别可以通过下面的例子更好地理解:

代码片段

object CallbyExample extends App {

  // function definition of call by value
  def CallbyValue(x: Long): Unit = {
    println("The current system time via CBV: " + x);
    println("The current system time via CBV " + x);
  }

  // function definition of call by name
  def CallbyName(x: => Long): Unit = {
    println("The current system time via CBN: " + x);
    println("The current system time via CBN: " + x);
  }

  // function call
  CallbyValue(System.nanoTime());
  println("\n")
  CallbyName(System.nanoTime());
}

输出

The current system time via CBV: 1153969332591521
The current system time via CBV 1153969332591521


The current system time via CBN: 1153969336749571
The current system time via CBN: 1153969336856589

在上面的代码片段中，对于函数调用CallbyValue(system . nanotime())，系统纳米时间是预先计算的，并且预先计算的值已将参数传递给函数调用。

但是在CallbyName(System.nanoTime())函数调用中，表达式“System.nanoTime())”本身作为参数传递给函数调用，当在函数内部使用该参数时，将计算该表达式的值。

注意CallbyName函数的函数定义，其中有一个=>符号分隔参数x及其数据类型。这里的特定符号表明该函数是按名称调用类型的。

换句话说，按值调用的函数实参在进入函数之前求值一次，而按名称调用的函数实参仅在需要时才在函数内部求值。

希望这能有所帮助!

下面是Martin Odersky的一个例子:

def test (x:Int, y: Int)= x*x

我们希望检查评估策略，并确定在这些条件下哪个更快(步骤更少):

test (2,3)

按值调用:test(2,3) -> 2*2 -> 4 按名称调用:test(2,3) -> 2*2 -> 4 这里的结果是用相同数量的步骤达到的。

test (3+4,8)

按值调用:test (7,8) -> 7*7 -> 49 按名字呼叫:(3+4)(3+4)-> 7(3+4)-> 7*7 ->49 这里按值调用更快。

test (7,2*4)

按值调用:test(7,8) -> 7*7 -> 49 按名字呼叫:7 * 7 -> 49 在这里叫名字比较快

test (3+4, 2*4) 

按值调用:test(7,2*4) -> test(7,8) -> 7*7 -> 49 按名字呼叫:(3+4)(3+4)-> 7(3+4)-> 7*7 -> 49 结果是在相同的步骤中达到的。

在你的例子中，所有的参数都将在函数中调用之前被求值，因为你只是通过值定义它们。 如果你想通过名称定义参数，你应该传递一个代码块:

def f(x: => Int, y:Int) = x

这样，在函数中调用参数x之前，将不会计算参数x。

这篇小文章也很好地解释了这一点。

我将尝试通过一个简单的用例来解释，而不仅仅是提供一个示例

想象一下，你想要创建一个“唠叨应用程序”，每当你被唠叨时，它就会唠叨你。

检查以下实现:

object main  {

    def main(args: Array[String]) {

        def onTime(time: Long) {
            while(time != time) println("Time to Nag!")
            println("no nags for you!")
        }

        def onRealtime(time: => Long) {
            while(time != time) println("Realtime Nagging executed!")
        }

        onTime(System.nanoTime())
        onRealtime(System.nanoTime())
    }
}

在上述实现中，nagger只在通过名称传递时才会工作 原因是，当通过值传递时，它将被重用，因此值将不会被重新计算，而当通过名称传递时，值将在每次访问变量时重新计算