Expressions plutôt qu’instructions
Tout est une expression
Expressions plutôt qu’instructions est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 3 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.
Expressions et instructions
Une instruction effectue une action, mais ne renvoie rien d’utile. Une expression s’évalue en une valeur.
En Scala, presque tout est une expression. C’est une idée fondamentale qui influence la manière dont vous écrivez du code.
if est une expression
Dans de nombreux langages, if est une instruction. En Scala, if/else renvoie une valeur : vous pouvez donc l’affecter directement à une val.
Il n’est pas nécessaire d’avoir une variable distincte affectée dans chaque branche.
object Main {
def main(args: Array[String]): Unit = {
val temp = 30
val label = if (temp > 25) "hot" else "mild"
println(label)
}
}Les blocs sont des expressions
Un bloc { ... } est lui aussi une expression. Sa valeur est celle de sa dernière ligne.
Vous pouvez donc calculer des valeurs intermédiaires, puis terminer par le résultat.
object Main {
def main(args: Array[String]): Unit = {
val result = {
val a = 2
val b = 3
a * b
}
println(result)
}
}match est une expression
La mise en correspondance de motifs avec match renvoie elle aussi une valeur. Chaque branche produit un résultat et l’expression entière fournit la valeur de la branche sélectionnée.
object Main {
def main(args: Array[String]): Unit = {
val day = 3
val name = day match {
case 1 => "Mon"
case 2 => "Tue"
case 3 => "Wed"
case _ => "Other"
}
println(name)
}
}Le type Unit
Certaines expressions existent uniquement pour leur effet de bord, comme println. Elles renvoient Unit, noté ().
Unit ressemble à void dans d’autres langages, mais reste une véritable valeur.
object Main {
def main(args: Array[String]): Unit = {
val nothing: Unit = println("side effect")
println(nothing)
}
}Renvoyer une valeur depuis des fonctions
Comme le corps d’une fonction est une expression, la dernière expression constitue sa valeur de retour. Vous avez rarement besoin du mot-clé return.
Ici, le corps de la fonction est une seule expression.
object Main {
def max(a: Int, b: Int): Int = if (a > b) a else b
def main(args: Array[String]): Unit = {
println(max(7, 4))
}
}Fonctions orientées expressions
Une fonction peut être une expression bloc dont la dernière ligne constitue le résultat. Cela permet de garder une logique concise et d’éviter les valeurs temporaires mutables.
object Main {
def discount(price: Double): Double = {
val rate = if (price > 100) 0.2 else 0.1
price * (1 - rate)
}
def main(args: Array[String]): Unit = {
println(discount(150.0))
}
}Pas besoin de mutation
Comme if et match sont des expressions, vous pouvez affecter leur résultat à une val au lieu de modifier une var.
Vous obtenez ainsi un code plus propre et plus fonctionnel.
object Main {
def main(args: Array[String]): Unit = {
val score = 85
val grade = if (score >= 90) "A"
else if (score >= 80) "B"
else "C"
println(grade)
}
}Composer des expressions
Comme chaque élément renvoie une valeur, les expressions peuvent s’imbriquer et se composer librement. La sortie de l’une devient l’entrée de l’autre.
Cette composabilité explique en grande partie pourquoi Scala est si expressif.
object Main {
def main(args: Array[String]): Unit = {
val n = 7
val message = "n is " + (if (n % 2 == 0) "even" else "odd")
println(message)
}
}Pourquoi est-ce important ?
Le code orienté expressions :
- Réduit le recours aux variables mutables
- Rend explicite le flux des valeurs
- Se compose naturellement en programmes plus vastes
- S’accorde parfaitement avec l’immuabilité
Tout réunir
Ici, une expression bloc contient une expression if, le tout étant affecté à un seul résultat immuable.
object Main {
def main(args: Array[String]): Unit = {
val total = {
val items = 3
val each = 12
val raw = items * each
if (raw > 30) raw - 5 else raw
}
println(total)
}
}Vérification rapide
Vérifiez votre compréhension des expressions.
Récapitulatif
Vous avez appris qu’en Scala, presque tout est une expression :
if/else,matchet les blocs renvoient tous des valeurs- La valeur d’un bloc est celle de sa dernière expression
- Les expressions produisant des effets de bord renvoient
Unit(()) - La dernière expression d’une fonction est sa valeur de retour
- Cela réduit la mutation et améliore la composabilité
Questions Fréquemment Posées
La leçon « Expressions plutôt qu’instructions » est-elle gratuite ?
Oui — le texte complet de « Expressions plutôt qu’instructions » 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 « Expressions plutôt qu’instructions » ?
Tout est une expression 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 3 sur 4.
Combien de temps prend la leçon « Expressions plutôt qu’instructions » ?
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.
Toutes les leçons de ce cours
- Utiliser le REPL
- val, var et types
- Expressions plutôt qu’instructions
- Interpolation de chaînes