val et var

En Scala, vous associez un nom à une valeur avec val ou var.

val crée une liaison immuable : une fois affectée, elle ne peut plus pointer vers une autre valeur. var crée une liaison modifiable que vous pouvez réaffecter ultérieurement.

Choisir entre les deux est l’une des premières habitudes que développe un ingénieur backend Scala.

Une val est en lecture seule. Vous lui attribuez une valeur une seule fois, et le compilateur garantit qu’elle restera inchangée.

Votre code est ainsi plus facile à comprendre : une val ne vous surprend jamais par une valeur modifiée ailleurs.

Essayer de réaffecter une val provoque une erreur de compilation, et non un plantage à l’exécution. Le compilateur vous arrête avant même que le programme ne s’exécute.

L’extrait ci-dessous échouerait avec reassignment to val.

Une var peut être réaffectée autant de fois que vous le souhaitez, tant que la nouvelle valeur possède un type compatible.

Utilisez var lorsqu’une valeur doit réellement changer au fil du temps, par exemple un compteur dans une boucle.

Bien qu'un var puisse être réaffecté, son type est fixé au moment de sa définition.

Si level commence comme un Int, vous ne pouvez pas ensuite y stocker une String. Le compilateur rejette cette incompatibilité.

En Scala idiomatique, val est privilégié presque partout. L'immutabilité évite de nombreuses catégories de bogues et rend le code concurrent plus sûr.

• Commencez par utiliser val.
• Passez à var uniquement lorsque vous avez réellement besoin de modifier la valeur.

De nombreuses boucles qui semblent nécessiter un var peuvent être exprimées avec un val et une expression.

Ici, une somme est calculée avec une plage et sum, sans modification nécessaire.

val et var existent tous deux à l'intérieur du bloc { ... } où ils sont définis.

Une liaison déclarée dans un bloc n'est pas visible à l'extérieur de celui-ci. Cela permet de garder les noms organisés et d'éviter leur réutilisation accidentelle.

Un lazy val n'est calculé que la première fois qu'il est utilisé, puis sa valeur est mise en cache.

C'est pratique pour les valeurs coûteuses à calculer dont vous n'aurez peut-être pas toujours besoin. Le corps est exécuté au plus une fois.

Vous pouvez annoter le type d'une liaison après deux-points. Cela documente l'intention et peut élargir volontairement le type.

Ici, amount est déclaré comme un Double, même si 10 ressemble à un Int.

Les deux se comportent de la même manière jusqu'à ce que vous essayiez de réaffecter une valeur.

• val x : assigné une fois, définitivement fixé.
• var y : assigné et réassigné librement.

Le programme ci-dessous n'incrémente que le var.

Vous avez appris les deux façons de lier des noms en Scala.

• val est immuable et constitue le choix par défaut.
• var est mutable et réservé aux valeurs qui doivent changer.
• Réaffecter un val provoque une erreur de compilation.
• Les types sont fixes dans les deux cas ; lazy val diffère le calcul.