Scala 传递参数（）=>；之间有什么区别；只是

具体而言，以下两种定义的区别是什么：

  def func(f: () => String) = f()
  def func1(s: String) = s

我写了一些代码来测试它们，似乎它们产生了相同的结果；在这个场景中，这两个定义是否完全相同；或者他们确实有一些不同

  var x = 1

  def f() = {
    x = x + 1
    s"$x"
  }

  println(func1(f))
  println(func1(f))
  println(func1(f))

  println(func(f))
  println(func(f))
  println(func(f))

这个函数接受返回字符串的函数作为参数

def func1(s: String) = s

而这个简单函数需要一个字符串作为参数

除了上面的微小技术差异之外，在这种情况下，它们的功能似乎是相同的。但是，函数参数可能更强大，因为它是一个可以从其他几个操作中导出其返回值的函数。然而，我认为主要的区别在于函数参数允许您决定何时导出值

这个函数接受返回字符串的函数作为参数

def func1(s: String) = s

而这个简单函数需要一个字符串作为参数

---

除了上面的微小技术差异之外，在这种情况下，它们的功能似乎是相同的。但是，函数参数可能更强大，因为它是一个可以从其他几个操作中导出其返回值的函数。但是，我认为主要的区别在于函数参数允许您决定何时派生值。

我想添加一个使用

（）=>字符串的示例

def printFuncResult(f: () => String) = println(f() + " " + f())

def ran = () => Math.random.toString

printFuncResult(ran)
printFuncResult(Math.random.toString)

当您传递函数（如
ran
）时，很可能会打印两个不同的值（此处涉及随机性）。当您传递一个固定的随机数时，它将被打印两次

如您所见：当您将函数作为参数时，每次在
printfuncsult
中使用它时，可能会产生不同的值。当您只输入
字符串
参数时，这是不可能的。
我想添加一个使用
（）=>字符串的示例

def printFuncResult(f: () => String) = println(f() + " " + f())

def ran = () => Math.random.toString

printFuncResult(ran)
printFuncResult(Math.random.toString)

def func(f: () => String) = f()
def func1(s: String) = s

println(func1(f)) // in this case f is evaluated first, its value is used in func1.

println(func(f)) // in this case f is NOT evaluated, but passed as it is to func.
                 // It is upto func to call f whenever needed, or even not call it.

当您传递函数（如
ran
）时，很可能会打印两个不同的值（此处涉及随机性）。当您传递一个固定的随机数时，它将被打印两次

如您所见：当您将函数作为参数时，每次在
printfuncsult
中使用它时，可能会产生不同的值。当您仅输入
字符串
参数时，这是不可能的

def func(f: () => String) = f()
def func1(s: String) = s

println(func1(f)) // in this case f is evaluated first, its value is used in func1.

println(func(f)) // in this case f is NOT evaluated, but passed as it is to func.
                 // It is upto func to call f whenever needed, or even not call it.

正是这种对f的“惰性”求值使func更有用，例如，f可以传递给其他一些高阶函数，也可以异步调用

正是这种对f的“惰性”求值使func更有用，例如，f可以传递给其他一些高阶函数，也可以异步调用
 在这个场景中，它们可能是相同的，但是当a
（）=>a
和a
a
有很大不同时，还有很多其他场景<代码>（）=>A
称为A，用于将一段延迟计算传递给函数。直到调用的函数决定对其求值，“thunk”的主体才进行求值。否则，传入的参数的值由调用方计算

考虑此示例，其中采用thunk的版本与仅采用值的版本之间存在差异：

    object Thunk {
  def withThunk(f: () ⇒ String): Unit = {
    println("withThunk before")
    println("the thunk's value is: " + f())
    println("now the thunk's value is: " + f())
  }

  def withoutThunk(f: String): Unit = {
    println("withoutThunk before")
    println("now the value's value is: " + f)
  }

  def main(argv: Array[String]): Unit = {
    withThunk { () ⇒ println("i'm inside a thunk"); "thunk value" }
    println("------------")
    withoutThunk { println("i'm not inside a thunk"); "just a value" }
  }
}

本程序将演示一些差异。在thunk版本中，您会看到“withThunk before”在第一次打印“我在thunk中”之前打印，这会打印两次，因为f（）会计算两次。在非thunk版本中，“我不在thunk内”在“之前没有thunk”之前打印，因为这是在作为参数发送到函数之前进行计算的。
在这种情况下，它们可能是相同的，但是当a
（）=>a
和a
a
有很大不同时，还有很多其他情况<代码>（）=>A

称为A，用于将一段延迟计算传递给函数。直到调用的函数决定对其求值，“thunk”的主体才进行求值。否则，传入的参数的值由调用方计算

考虑此示例，其中采用thunk的版本与仅采用值的版本之间存在差异：

    object Thunk {
  def withThunk(f: () ⇒ String): Unit = {
    println("withThunk before")
    println("the thunk's value is: " + f())
    println("now the thunk's value is: " + f())
  }

  def withoutThunk(f: String): Unit = {
    println("withoutThunk before")
    println("now the value's value is: " + f)
  }

  def main(argv: Array[String]): Unit = {
    withThunk { () ⇒ println("i'm inside a thunk"); "thunk value" }
    println("------------")
    withoutThunk { println("i'm not inside a thunk"); "just a value" }
  }
}

本程序将演示一些差异。在thunk版本中，您会看到“withThunk before”在第一次打印“我在thunk中”之前打印，这会打印两次，因为f（）会计算两次。在非thunk版本中，“我不在thunk中”在“without thunk before”之前打印，因为这是在作为参数发送到函数之前进行计算的