scala - "def"和 "val"定义函数有什么区别

Question

有什么区别:

def even: Int => Boolean = _ % 2 == 0

和

val even: Int => Boolean = _ % 2 == 0

两者都可以像 even(10) 那样调用。

Answer 1

方法 def Even 在调用时计算并每次创建新函数(Function1 的新实例)。

def even: Int => Boolean = _ % 2 == 0
even eq even
//Boolean = false

val even: Int => Boolean = _ % 2 == 0
even eq even
//Boolean = true

使用 def 你可以在每次调用时获得新函数:

val test: () => Int = {
  val r = util.Random.nextInt
  () => r
}

test()
// Int = -1049057402
test()
// Int = -1049057402 - same result

def test: () => Int = {
  val r = util.Random.nextInt
  () => r
}

test()
// Int = -240885810
test()
// Int = -1002157461 - new result

val 在定义时计算，def - 在调用时计算:

scala> val even: Int => Boolean = ???
scala.NotImplementedError: an implementation is missing

scala> def even: Int => Boolean = ???
even: Int => Boolean

scala> even
scala.NotImplementedError: an implementation is missing

请注意，还有第三个选项:lazy val。

它在第一次调用时进行评估:

scala> lazy val even: Int => Boolean = ???
even: Int => Boolean = <lazy>

scala> even
scala.NotImplementedError: an implementation is missing

但每次都返回相同的结果(在本例中为 FunctionN 的相同实例):

lazy val even: Int => Boolean = _ % 2 == 0
even eq even
//Boolean = true

lazy val test: () => Int = {
  val r = util.Random.nextInt
  () => r
}

test()
// Int = -1068569869
test()
// Int = -1068569869 - same result

性能

val 在定义时进行计算。

def 在每次调用时都会进行计算，因此对于多次调用，性能可能会比 val 更差。只需一次调用即可获得相同的性能。如果没有调用，您将不会从 def 获得任何开销，因此即使您不会在某些分支中使用它，您也可以定义它。

使用lazy val，你会得到一个惰性求值:即使你不会在某些分支中使用它，你也可以定义它，并且它会求值一次或从不求值，但你会得到一个每次访问lazy val时双重检查锁定的开销很小。

正如 @SargeBorsch 指出的，您可以定义方法，这是最快的选项:

def even(i: Int): Boolean = i % 2 == 0

但是，如果您需要一个函数(而不是方法)来进行函数组合或高阶函数(例如 filter(even))，编译器会在您每次将其用作方法时从您的方法生成一个函数函数，因此性能可能比 val 稍差。

使用 java 8+ lambda 优化，将方法转换为函数是一种廉价的操作。