`def` vs `val` vs `paresseux val d'évaluation en Scala

Oui, mais pour la 3ème, je dirais "que l'exécution de l'instruction", parce que, par exemple:

def foo() {
    new {
        val a: Any = sys.error("b is " + b)
        val b: Any = sys.error("a is " + a)
    }
}

Cela donne "b is null". b n'est jamais évalué et son erreur est de ne jamais levée. Mais c'est dans la portée dès que le contrôle entre dans le bloc.

OriginalL'auteur Owen

Je tiens à expliquer les différences à travers l'exemple que j'ai exécuté dans REPL.Je crois que cet exemple simple est plus facile à saisir et explique les différences conceptuelles.

Ici,je suis entrain de créer un val result1, un paresseux val result2 et un def result3 dont chacun a un type Chaîne de caractères.

Un). val

scala> val result1 = {println("hello val"); "returns val"}
hello val
result1: String = returns val

Ici, println est exécuté parce que la valeur de result1 a été calculé ici. Alors, maintenant, result1 va toujours se référer à sa valeur je.e "renvoie val".

scala> result1
res0: String = returns val

Donc, maintenant, vous pouvez voir que result1 fait maintenant référence à sa valeur. Notez que, la println instruction n'est pas exécutée ici, car la valeur de result1 a déjà été calculée quand il a été exécuté pour la première fois. Donc, désormais, result1 retourne toujours la même valeur et println déclaration ne sera jamais exécutée à nouveau, car le calcul pour obtenir la valeur de result1 a déjà été effectué.

B). paresseux val

scala> lazy val result2 = {println("hello lazy val"); "returns lazy val"}
result2: String = <lazy>

Comme nous pouvons le voir ici, la println instruction n'est pas exécutée ici et ni la valeur a été calculée. C'est la nature de paresse.

Maintenant, quand je me réfère à la result2 pour la première fois, println instruction sera exécutée et la valeur sera calculée et attribuée.

scala> result2
hello lazy val
res1: String = returns lazy val

Maintenant, quand je me réfère à result2 de nouveau, cette fois-ci, nous allons seulement voir la valeur qu'il détient et de la println déclaration ne sera pas exécutée. À partir de maintenant, result2 va se comporter comme un val et renvoie sa valeur en cache tout le temps.

scala> result2
res2: String = returns lazy val

C). def

En cas de def, le résultat devra être calculée à chaque fois result3 est appelé. C'est aussi la principale raison pour laquelle nous de définir des méthodes comme def en scala, car les méthodes de calcul et de retourner une valeur à chaque fois qu'il est appelé à l'intérieur du programme.

scala> def result3 = {println("hello def"); "returns def"}
result3: String

scala> result3
hello def
res3: String = returns def

scala> result3
hello def
res4: String = returns def

OriginalL'auteur oblivion

Vous sont corrects. Pour preuve de la spécification:

De "3.3.1 Types de Méthode" (pour def):

Sans paramètre méthodes nom des expressions qui sont réévalués à chaque fois
la méthode sans paramètre nom est référencé.

De "4.1 les Déclarations de Valeur et de Définitions":

Une définition de la valeur val x : T = e définit x comme un nom de la valeur qui résulte de
l'évaluation de e.

Un paresseux définition de la valeur évalue son côté droit e la première
fois que la valeur est accessible.

OriginalL'auteur Travis Brown

Un nom qualifié par la def est évalué par le remplacement du nom et de son membre de droite de l'expression à chaque fois le nom apparaît dans le programme. Par conséquent, ce remplacement sera exécutée à chaque où le nom apparaît dans votre programme.

Un nom qualifié par val est évalué immédiatement lorsque le contrôle atteint son membre de droite de l'expression. Par conséquent, chaque fois que le nom apparaît dans l'expression, il sera considéré comme de la valeur de cette évaluation.

Un nom qualifié par paresse val suit la même politique que celle de val de qualification avec une exception, de son RHS sera évaluée uniquement lorsque le contrôle de la frappe le point où le nom est utilisé pour la première fois

OriginalL'auteur kmos.w