[scala] 게으른 발은 무엇을합니까?

이들의 차이점은 a val는 정의 lazy val될 때 실행되는 반면 a 는 처음 액세스 할 때 실행된다는 것입니다.

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) 메소드와 달리 a 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

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()

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

x
-----
y
y is: 18

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

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

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 

// 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

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

scala> lazyEight
I am lazy !
res1: Int = 8