[scala] 함수를 정의하기 위해 “def”와 “val”의 차이점은 무엇입니까

메소드 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.

답변

scala> def even: (Int => Boolean) = {
             println("def");
             (x => x % 2 == 0)
       }
even: Int => Boolean

scala> val even2: (Int => Boolean) = {
             println("val");
             (x => x % 2 == 0)
       }
val //gets printed while declaration. line-4
even2: Int => Boolean = <function1>

scala> even(1)
def
res9: Boolean = false

scala> even2(1)
res10: Boolean = false

scala> import scala.util.Random
import scala.util.Random

scala> val x = { Random.nextInt }
x: Int = -1307706866

scala> x
res0: Int = -1307706866

scala> x
res1: Int = -1307706866

scala> lazy val y = { Random.nextInt }
y: Int = <lazy>

scala> y
res4: Int = 323930673

scala> y
res5: Int = 323930673

  var x = 2 // using var as I need to change it to 3 later
  val sq = x*x // evaluates right now
  x = 3 // no effect! sq is already evaluated
  println(sq)

   {
         println("val");
         (x => x % 2 == 0)
   }

val even2: (Int => Boolean) = {
             println("val");
             (x => x % 2 == 0)
       }

scala> even2(2)
res7: Boolean = true

scala> even2(3)
res8: Boolean = false

scala> val even2: (Int => Boolean) = {
     |              println("val");
     |              (x => {
     |               println("inside final fn")
     |               x % 2 == 0
     |             })
     |        }

scala> even2(3)
inside final fn
res9: Boolean = false

scala> even2(2)
inside final fn
res10: Boolean = true

scala> 

def test1: Int => Int = {
x => x
}
--test1: test1[] => Int => Int

def test2(): Int => Int = {
x => x+1
}
--test2: test2[]() => Int => Int

def test3(): Int = 4
--test3: test3[]() => Int