Quelle est la différence entre "def" et "val" pour définir une fonction

Quelle est la différence entre:

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

et

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

Les deux peuvent être appelés comme even(10).

Méthode def even évalue à l'appel et crée à chaque fois une nouvelle fonction (nouvelle instance de Function1).

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

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

Avec def vous pouvez obtenir une nouvelle fonction à chaque appel:

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 évalue une fois défini, def - lorsqu'il est appelé:

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

Notez qu'il existe une troisième option: lazy val.

Il évalue lors de son premier appel:

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

scala> even
scala.NotImplementedError: an implementation is missing

Mais renvoie le même résultat (dans ce cas la même instance de FunctionN) à chaque fois:

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

Performance

val évalue une fois défini.

defévalue à chaque appel, les performances peuvent donc être pires que valpour plusieurs appels. Vous obtiendrez les mêmes performances avec un seul appel. Et sans appels, vous n'aurez aucun frais générauxdef , vous pouvez donc le définir même si vous ne l'utiliserez pas dans certaines branches.

Avec un, lazy valvous obtiendrez une évaluation paresseuse: vous pouvez le définir même si vous ne l'utiliserez pas dans certaines branches, et il évalue une fois ou jamais, mais vous obtiendrez un petit supplément de verrouillage double vérification sur chaque accès à votre lazy val.

Comme @SargeBorsch l'a noté, vous pouvez définir une méthode, et c'est l'option la plus rapide:

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

Mais si vous avez besoin d'une fonction (et non d'une méthode) pour la composition de fonctions ou pour des fonctions d'ordre supérieur (comme filter(even)), le compilateur générera une fonction à partir de votre méthode chaque fois que vous l'utiliserez comme fonction, donc les performances pourraient être légèrement pires qu'avec val.

Considère ceci:

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

Voyez-vous la différence? En bref:

def : Pour chaque appel à even, il appelle à nouveau le corps de la evenméthode. Mais avec even2ie val , la fonction n'est initialisée qu'une seule fois lors de la déclaration (et donc elle s'imprime valà la ligne 4 et plus jamais) et la même sortie est utilisée à chaque fois qu'elle y accède. Par exemple, essayez de faire ceci:

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

Lorsque xest initialisé, la valeur renvoyée par Random.nextIntest définie comme valeur finale de x. La prochaine foisx utiliserez à nouveau, il renverra toujours la même valeur.

Vous pouvez également initialiser paresseusement x. c'est-à-dire que la première fois qu'il est utilisé, il est initialisé et non pendant la déclaration. Par exemple:

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

scala> y
res4: Int = 323930673

scala> y
res5: Int = 323930673

Regarde ça:

  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)

Étonnamment, cela imprimera 4 et non 9! val (même var) est évalué immédiatement et affecté.
Maintenant changez val en def .. il imprimera 9! Def est un appel de fonction .. il évaluera chaque fois qu'il est appelé.

val ie "sq" est par définition Scala est fixe. Il est évalué juste au moment de la déclaration, vous ne pouvez pas le modifier ultérieurement. Dans d'autres exemples, où even2 vaut également, mais il a déclaré avec la signature de fonction, c'est-à-dire "(Int => Boolean)", donc ce n'est pas de type Int. C'est une fonction et sa valeur est définie par l'expression suivante

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

Selon la propriété Scala val, vous ne pouvez pas affecter une autre fonction à even2, même règle que sq.

Pourquoi pourquoi appeler la fonction val eval2 n'imprime-t-il pas encore "val"?

Code d'origine:

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

Nous savons que, dans Scala, la dernière déclaration du type d'expression ci-dessus (à l'intérieur de {..}) est en fait de retour sur le côté gauche. Ainsi, vous finissez par définir even2 sur la fonction "x => x% 2 == 0", qui correspond au type que vous avez déclaré pour le type val even2, c'est-à-dire (Int => Boolean), donc le compilateur est content. Maintenant, even2 ne pointe que sur la fonction "(x => x% 2 == 0)" (pas d'autre instruction avant ie println ("val") etc. L'invocation de event2 avec différents paramètres invoquera en fait "(x => x% 2 == 0) ", car seul celui-ci est enregistré avec event2.

scala> even2(2)
res7: Boolean = true

scala> even2(3)
res8: Boolean = false

Juste pour clarifier cela, voici une version différente du code.

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

Que va-t-il se passer? ici, nous voyons "inside final fn" imprimé encore et encore, lorsque vous appelez even2 ().

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

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

scala> 

Exécution d'une définition telle que def x = e n'évaluera pas l'expression e. Au lieu de cela, e est évalué chaque fois que x est invoqué.

Scala propose également une définition de valeur val x = e, qui évalue le côté droit dans le cadre de l'évaluation de la définition. Si x est ensuite utilisé par la suite, il est immédiatement remplacé par la valeur pré-calculée de e, de sorte que l'expression n'a pas besoin d'être évaluée à nouveau.

aussi, Val est une évaluation par valeur. Ce qui signifie que l'expression de droite est évaluée lors de la définition. Où Def est par évaluation de nom. Il n'évaluera pas jusqu'à ce qu'il soit utilisé.

En plus des réponses utiles ci-dessus, mes conclusions sont les suivantes:

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

Ce qui précède montre que «def» est une méthode (avec zéro paramètre d'argument) qui renvoie une autre fonction «Int => Int» lorsqu'elle est invoquée.

La conversion des méthodes en fonctions est bien expliquée ici: https://tpolecat.github.io/2014/06/09/methods-functions.html

Dans REPL,

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

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

def signifie call-by-name, évalué sur demande

val signifie call-by-value, évalué lors de l'initialisation