Def&quot &quot 차이가 뭘까;; 및 &quot val"; 함수를 정의하는 데

차이가 뭘까.

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

및

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

' (10)' 등 모두 호출할 수 있다.

Amir Karimi
편집된 질문29일 1월 2014 в 9:24
프로그래밍
scala
19일 9월 2013 в 6:08
10 파운드
질문에 대한 의견 (5)
해결책

심지어 '정의' 는 새로운 함수를 만들 수 있는 방법을 호출하십시오 항상 (Function1 새 인스턴스를 '').

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

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

'정의' 와 있는 모든 호출하십시오 새로운 함수를 얻을 수 있습니다.

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

'발', '정의' 라고 정의할 때 상기하 평가합니다.

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

단, 세 번째가 있습니다. '게으른 발'.

이 때 처음으로 불렀으매 평가합니다.

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

scala> even
scala.NotImplementedError: an implementation is missing

하지만 동일한 결과를 되돌려줍니다 때마다 (이 경우 동일한 인스턴스에서는 '펑크티온').

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
  • 성능 *

'발' 정의할 때 평가합니다.

'정의' 는 '발' 을 여러 번 통화를 할 수 있는 모든 매입옵션 도왔으매 성능을 밑구녕만도. # 39, ll 내려받습니다 you& 동일한 성능을 가진 단일 통화. '정의' ll get no. # 39 와 전화는 you& 비용 부담 때문에 사용하지 않는 일부 분기로서의 이 경우에도 정의할 수 있습니다.

'발' ll get a # 39 로 게으른 you&, 느긋한 계산법: 이 경우에도 정의할 수 있습니다, 그것은 결코 사용하지 않을 것이라고 평가하고 있지만, 일부 분기로서의 한 번 또는 ll get a little 오버헤드에 you& # 39 에서 '게으른 발' 양수겸장 잠금식 매년 액세스할 수 있습니다.

이것이 가장 빠른 방법 및 옵션을 @SargeBorsch 따라 다음과 같이 정의할 수 있습니다.

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

하지만 필요할 경우 함수은 함수 컴포지션이나 아닌 방법) 보다 높은 오더할 기능 (like '필터 (짝수)') 컴파일러 기능을 사용하는 방법을 통해 정보기술 (it) 을 낼 수 있을 때마다 '발' 기능 등을 통해 성능이 약간 밑구녕만도 될 수 있다.

Ismail Marmoush
편집된 답변25일 7월 2017 в 10:23
해설 (10)

이러한 측면에서 볼 때:

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 = 

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

scala> even2(1)
res10: Boolean = false

표시됩니까 차이? 한 마디로.

  • 소 소 데프 : 심지어 ',' 모든 '심지어' 메서드 호출이 본문을 다시 드러났다. , * 발 '즉' even2 단 한 번만 초기화되었습니다 기능이 동시에 선언 (4 호선 다시는 '발' 에 인쇄 및 업그레이드됨 정보기술 (it) 과 동일한 출력을 사용할 때마다 액세스되는. 예를 들어 이 작업을 시도해 봅니다.
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

'X' 는 '때' 를 마지막 값을 반환하는 값은 란도맥네스틴트 initialized 설정되었습니다 'x'. 다음에 다시 'x' 는 항상 같은 값을 반품하십시오 사용할 예정이다.

'X' 초기화하지 게으름을 수도 있습니다. 즉 처음 사용하는 것이 아니라 초기화되었습니다 동시에 선언. 예를 들면 다음과 같습니다.

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

scala> y
res4: Int = 323930673

scala> y
res5: Int = 323930673
Jatin
편집된 답변13일 2월 2014 в 8:48
해설 (4)

이 슬라이드에서는:

  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)

놀랍게도 이 인쇄됩니다 4 와 9 없습니다! 발 (심지어 var) 즉시 검사됩니다 assigned.&lt br>; 이제 발 변경하십시오 대한 정의. 또 9 인쇄하십시오! Def 는 함수 호출. 또 때마다 평가하십시오 호출됨.

해설 (0)

즉, 발 &quot sq&quot. 는 스칼라 정의는 고정식입니다. 이 당시 선언, 너회가 can& 오른쪽맞춤 검사됩니다 # 39, t, 추후 변경. 하지만 또 다른 사례, 여기서 even2 val (Int = &gt, 함수, 즉 &quot 선언되는 서명입니다 때문에 &quot 부울입니다), Int 형이 아니다. # 39 의 값은 다음과 같은 함수 및 it& 표현식에서는 설정한 것은

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

Val 속성에 따라 스칼라, t, 동일한 규칙을 따라 다른 기능을 너회가 can& # 39 할당할지 even2 sq.

발 없는 이유에 대해 eval2 호출하십시오 함수은 &quot 인쇄면이 val"; 다시?

오리지널 코드:

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

우리가 알고 있는 스칼라, 마지막 기술서임을 위에 종류의 표현식에서는 (δ1 {. 실제로 반품하십시오}) 가 왼쪽. 끝날 수 있도록 설정을 even2 &quot, x = &gt. x = 0&quot 2%. 즉, 이 함수는 (Int = &gt, 선언된 일치하는지 종류에 even2 발 유형 부울입니다) 이므로 컴파일러와의 만족입니다. 이제 만 &quot even2 점, (x = &gt. %2 x = 0) &quot. 함수 (즉, 모든 것은 전에 다른 기술서임을 프린틀린 (val&quot ";) 상술합니다. 실제로, 서로 다른 매개변수입니다 &quot 호출하십시오 event2 호출 (x = &gt. %2 x = 0) &quot. 단, 해당 코드를 event2 함께 저장됩니다.

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

어떤 일이 벌어질까? 여기에서는 인사이드라면 &quot 최종 fn"; 다시 인쇄했습니다 일러주라하셨으니 전화하시기 even2 ().

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

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

scala>
해설 (0)

X = e '정의' def 실행 등 평가하십시오 ᅦ 표현식에서는 않습니다. E - 에서 x 는 대신 때마다 검사됩니다 호출되었을.

또는 스칼라 값 정의 제공합니다. 'e', '발 x = 않는 대한 평가는 오른편 평가하십시오 일부로 정의할 수 있다. 그 후, 바로 대체할 경우 x 가 사용될 때 미리 계산 값 e 도왔으매 표현식에서는 다시 평가하실 필요는 없습니다.

해설 (0)

의 복제,

scala> def even: Int => Boolean = { _% 2 == 0 }
even: Int => Boolean

scala> val even: Int => Boolean = { _% 2 == 0 }
even: Int => Boolean = $$Lambda$1157/1017502292@57a0aeb8

'정의', 필요에 따라 이름으로 호출하십시오 고말은 평가하실

한편 ',' 발 고말은 call by value 평가하실 초기화하지

해설 (1)

또한 위의 도움됐네 답변 내 발견사항 다음과 같습니다.

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

위의 "def" 는 것을 알 수 있는 또 다른 기능, Int = &gt &quot 되돌려줍니다 방법 (없이 인수 매개변수). Int '호출되었을 때.

이 기능을 잘 frequencyid 변환되게 방법을 설명했다. https://tpolecat.github.io/2014/06/09/methods-functions.html

jkdev
편집된 답변11일 7월 2018 в 8:41
해설 (0)

또한, Val 은 by value 평가. 즉 오른쪽 표현식에서는 검사됩니다 정의 중. 여기서 Def 는 이름 평가. # 39 에 사용되는 it& 때까지 평가하십시오 않을 것입니다.

해설 (0)