val, var et types
Liaisons et inférence
val, var et types est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Liaisons en Scala
En Scala, vous donnez des noms aux valeurs à l’aide de liaisons. Les deux mots-clés sont val et var.
Une val est immuable (elle ne peut pas être réaffectée), tandis qu’une var est mutable (elle peut être réaffectée).
Déclarer une val
Une val lie un nom à une valeur une seule fois. Essayer de la réaffecter provoque une erreur de compilation.
Privilégiez val par défaut. L’immuabilité facilite la compréhension du code.
object Main {
def main(args: Array[String]): Unit = {
val name = "Ada"
println(name)
}
}Déclarer une var
Une var peut être réaffectée avec =. Utilisez-la uniquement lorsque vous avez réellement besoin d’un état mutable.
Notez que la nouvelle valeur doit malgré tout être du même type que la valeur initiale.
object Main {
def main(args: Array[String]): Unit = {
var count = 0
count = count + 1
count = count + 1
println(count)
}
}Inférence de type
Scala détermine généralement le type à votre place. Écrire val x = 42 fait automatiquement de x un Int.
On appelle cela l’inférence de type : vous bénéficiez du typage statique sans devoir toujours écrire le type.
object Main {
def main(args: Array[String]): Unit = {
val x = 42
val pi = 3.14
val flag = true
println(x)
println(pi)
println(flag)
}
}Annotations de type explicites
Vous pouvez aussi indiquer explicitement le type après deux-points : val x: Int = 42.
C’est utile pour la documentation ou pour choisir un type plus large que celui qui a été inféré.
object Main {
def main(args: Array[String]): Unit = {
val age: Int = 30
val price: Double = 9.99
val label: String = "Sale"
println(label + ": " + price)
}
}Types numériques courants
Scala possède plusieurs types numériques :
Intpour les nombres entiersLongpour les grands nombres entiersDoublepour les nombres décimauxFloatpour les nombres décimaux moins précis
Un littéral entier est par défaut de type Int ; un littéral décimal est par défaut de type Double.
object Main {
def main(args: Array[String]): Unit = {
val whole: Int = 7
val big: Long = 9000000000L
val dec: Double = 2.5
println(whole + dec)
}
}Boolean et Char
Boolean contient true ou false. Char contient un seul caractère écrit entre apostrophes.
Ce sont des types à part entière que vous pouvez stocker dans des vals et des vars.
object Main {
def main(args: Array[String]): Unit = {
val isReady: Boolean = true
val grade: Char = 'A'
println(isReady)
println(grade)
}
}Type String
String contient du texte entre guillemets doubles. Les chaînes sont immuables en Scala.
Vous pouvez les concaténer avec + et appeler sur elles de nombreuses méthodes utiles.
object Main {
def main(args: Array[String]): Unit = {
val first = "Grace"
val last = "Hopper"
val full = first + " " + last
println(full.toUpperCase)
}
}Pourquoi préférer val à var ?
Les valeurs immuables empêchent toute une catégorie de bogues : rien d’autre ne peut les modifier à votre insu.
- Elles sont plus faciles à comprendre
- Elles sont plus sûres dans du code concurrent
- Elles favorisent un style fonctionnel
N’utilisez var que lorsque la mutation est réellement nécessaire.
La sûreté des types en pratique
Comme Scala est à typage statique, le compilateur détecte les incompatibilités de types avant l’exécution du programme.
Affecter du texte à un Int échouerait lors de la compilation. Voici du code valide et correctement typé.
object Main {
def main(args: Array[String]): Unit = {
val quantity: Int = 3
val unitPrice: Double = 4.50
val total: Double = quantity * unitPrice
println(total)
}
}Assembler le tout
Combinez des liaisons immuables et mutables avec l’inférence et les annotations dans un petit programme.
Remarquez comment le compilateur suit chaque type à votre place.
object Main {
def main(args: Array[String]): Unit = {
val base = 100
var running = base
val step: Int = 25
running = running + step
println(running)
}
}Vérification rapide
Vérifiez votre compréhension des liaisons et des types.
Récapitulatif
Vous avez appris comment Scala nomme les valeurs :
valest une liaison immuable ;varest mutable- L’inférence de type détermine le type à partir de la valeur
- Vous pouvez ajouter des annotations explicites comme
val x: Int - Les types fondamentaux incluent
Int,Long,Double,Boolean,CharetString - Privilégiez
valpour un code plus sûr et plus clair
Apprends Scala avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 143
Questions Fréquemment Posées
La leçon « val, var et types » est-elle gratuite ?
Oui — le texte complet de « val, var et types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « val, var et types » ?
Liaisons et inférence Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « val, var et types » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.