lazy val做什么?

我注意到Scala提供了lazy vals。但我不明白他们是干什么的。

scala> val x = 15
x: Int = 15


scala> lazy val y = 13
y: Int = <lazy>


scala> x
res0: Int = 15


scala> y
res1: Int = 13

REPL表明y是一个lazy val，但它与正常的val有何不同?

120029 次浏览
小开
最佳答案

它们之间的区别是，val是在定义时执行的，而lazy val是在第一次访问时执行的。

scala> val x = { println("x"); 15 }
x
x: Int = 15


scala> lazy val y = { println("y"); 13 }
y: Int = <lazy>


scala> x
res2: Int = 15


scala> y
y
res3: Int = 13


scala> y
res4: Int = 13

与方法(用def定义)相反，lazy val只执行一次，然后不再执行。当一个操作需要很长时间才能完成，并且不确定以后是否会使用它时，这可能很有用。

scala> class X { val x = { Thread.sleep(2000); 15 } }
defined class X


scala> class Y { lazy val y = { Thread.sleep(2000); 13 } }
defined class Y


scala> new X
res5: X = X@262505b7 // we have to wait two seconds to the result


scala> new Y
res6: Y = Y@1555bd22 // this appears immediately

在这里，当值x和y从未被使用时，只有x不必要地浪费资源。如果我们假设y没有副作用，并且我们不知道它被访问的频率(从不，一次，数千次)，那么声明它为def是没有用的，因为我们不想多次执行它。

如果你想知道lazy vals是如何实现的，请参阅这个问题。

小开

这个特性不仅有助于延迟昂贵的计算，而且对于构造相互依赖或循环结构也很有用。例如，这会导致堆栈溢出:

trait Foo { val foo: Foo }
case class Fee extends Foo { val foo = Faa() }
case class Faa extends Foo { val foo = Fee() }


println(Fee().foo)
//StackOverflowException

但是对于lazy vals，它工作得很好

trait Foo { val foo: Foo }
case class Fee extends Foo { lazy val foo = Faa() }
case class Faa extends Foo { lazy val foo = Fee() }


println(Fee().foo)
//Faa()
小开

lazy在没有循环依赖的情况下也是有用的，如下面的代码所示:

abstract class X {
val x: String
println ("x is "+x.length)
}


object Y extends X { val x = "Hello" }
Y

访问Y现在将抛出空指针异常，因为x尚未初始化。 但是，下面的代码可以正常工作:

abstract class X {
val x: String
println ("x is "+x.length)
}


object Y extends X { lazy val x = "Hello" }
Y

编辑:以下也可以:

object Y extends { val x = "Hello" } with X

这被称为“早期初始化式”。更多细节参见这个SO问题。

小开

lazy val最容易理解为“memoize的 (no-arg) def”。

与def一样，lazy val在调用之前不会计算值。但是保存结果，以便后续调用返回保存的值。记住的结果会占用数据结构中的空间，就像val一样。

正如其他人所提到的，lazy val的用例是将昂贵的计算推迟到需要时，并存储它们的结果，以及解决值之间的某些循环依赖关系。

事实上，惰性val的实现或多或少就像记忆defs一样。你可以在这里阅读它们的实现细节:

http://docs.scala-lang.org/sips/pending/improved-lazy-val-initialization.html

小开

我知道答案已经给出了，但我写了一个简单的例子，让像我这样的初学者容易理解:

var x = { println("x"); 15 }
lazy val y = { println("y"); x + 1 }
println("-----")
x = 17
println("y is: " + y)

以上代码的输出为:

x
-----
y
y is: 18

可以看到，x在初始化时被打印出来，但y在以同样的方式初始化时没有被打印出来(这里我故意将x作为var -以解释y何时被初始化)。接下来，当y被调用时，它被初始化，并且最后一个'x'的值被考虑，而不是旧的。

希望这能有所帮助。

小开 
scala> lazy val lazyEight = {
|   println("I am lazy !")
|   8
| }
lazyEight: Int = <lazy>


scala> lazyEight
I am lazy !
res1: Int = 8
  • 所有val都在对象构造过程中初始化
  • 使用lazy关键字将初始化推迟到第一次使用
  • 注意:惰性值不是最终值，因此可能会显示性能缺陷
小开

lazy的演示-如上所定义-定义时执行vs访问时执行:(使用2.12.7 scala shell)

// compiler says this is ok when it is lazy
scala> lazy val t: Int = t
t: Int = <lazy>
//however when executed, t recursively calls itself, and causes a StackOverflowError
scala> t
java.lang.StackOverflowError
...


// when the t is initialized to itself un-lazily, the compiler warns you of the recursive call
scala> val t: Int = t
<console>:12: warning: value t does nothing other than call itself recursively
val t: Int = t

提交答案