Expressions match
Branchez selon la forme
Expressions match est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 1 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.
Qu’est-ce que match ?
match est une construction de branchement puissante de Scala. Vous lui fournissez une valeur et une série de motifs case ; il exécute la première branche correspondante.
Considérez-le comme une version plus puissante et orientée expressions d’une instruction switch.
Syntaxe de base
Vous écrivez value match { case pattern => result }. Chaque case définit un motif et le code à exécuter lorsqu’il correspond.
Comme match est une expression, l’ensemble renvoie une valeur.
object Main {
def main(args: Array[String]): Unit = {
val n = 2
val word = n match {
case 1 => "one"
case 2 => "two"
case 3 => "three"
}
println(word)
}
}Le cas générique
Le caractère souligné _ est un caractère générique qui correspond à n’importe quoi. Utilisez-le comme valeur par défaut attrape-tout à la fin.
Sans lui, une valeur sans correspondance déclenche une MatchError lors de l’exécution.
object Main {
def main(args: Array[String]): Unit = {
val n = 9
val word = n match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
println(word)
}
}Mettre des chaînes en correspondance
Les motifs ne se limitent pas aux nombres. Vous pouvez faire correspondre directement des littéraux de chaîne.
object Main {
def main(args: Array[String]): Unit = {
val cmd = "start"
val msg = cmd match {
case "start" => "Starting up"
case "stop" => "Shutting down"
case _ => "Unknown command"
}
println(msg)
}
}match renvoie une valeur
Puisque chaque branche produit une valeur, vous pouvez affecter le résultat de match à une val ou l’utiliser directement.
Votre code reste ainsi propre et évite les variables mutables.
object Main {
def main(args: Array[String]): Unit = {
val light = "red"
println(s"Action: " + (light match {
case "red" => "stop"
case "green" => "go"
case _ => "caution"
}))
}
}Combiner des cas
Vous pouvez faire correspondre plusieurs valeurs dans un même cas à l’aide de | (la barre verticale). Toutes les valeurs indiquées mènent à la même branche.
object Main {
def main(args: Array[String]): Unit = {
val day = "Sat"
val kind = day match {
case "Sat" | "Sun" => "weekend"
case _ => "weekday"
}
println(kind)
}
}match dans une fonction
Un schéma courant consiste à faire du corps entier de la fonction une seule expression match. Le résultat de la correspondance devient la valeur de retour.
object Main {
def describe(n: Int): String = n match {
case 0 => "zero"
case 1 => "one"
case _ => "other"
}
def main(args: Array[String]): Unit = {
println(describe(0))
println(describe(5))
}
}Lier la valeur entière
Vous pouvez lier la valeur correspondante à un nom dans le cas générique avec case other =>. Vous pouvez ensuite utiliser other dans cette branche.
object Main {
def main(args: Array[String]): Unit = {
val n = 42
val result = n match {
case 0 => "nothing"
case other => s"got $other"
}
println(result)
}
}L’ordre est important
Les cas sont testés de haut en bas et c’est la première correspondance qui l’emporte. Placez les motifs les plus spécifiques avant les motifs généraux.
Un caractère générique placé trop tôt masquerait les cas qui le suivent.
object Main {
def main(args: Array[String]): Unit = {
val n = 1
val msg = n match {
case 1 => "specific one"
case _ => "anything else"
}
println(msg)
}
}Pourquoi utiliser match ?
La mise en correspondance de motifs est essentielle en Scala, car elle :
- Est claire pour les branchements multiples
- Renvoie une valeur en tant qu’expression
- S’adapte aux types, aux structures de données et aux gardes
- Peut être vérifiée par le compilateur pour garantir son exhaustivité
Assembler le tout
Voici un petit classificateur utilisant des littéraux, un cas combiné et une valeur par défaut.
object Main {
def grade(score: Int): String = score match {
case 10 | 9 => "excellent"
case 8 | 7 => "good"
case _ => "keep trying"
}
def main(args: Array[String]): Unit = {
println(grade(9))
println(grade(7))
println(grade(3))
}
}Vérification rapide
Testez votre compréhension des expressions match.
Récapitulatif
Vous avez appris les bases de match :
- La syntaxe est
value match { case pattern => result } _est le caractère générique attrape-tout- Combinez des valeurs avec
| matchest une expression qui renvoie une valeur- Les cas sont essayés de haut en bas ; la première correspondance l’emporte
Questions Fréquemment Posées
La leçon « Expressions match » est-elle gratuite ?
Oui — le texte complet de « Expressions match » 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 match » ?
Branchez selon la forme 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 1 sur 4.
Combien de temps prend la leçon « Expressions match » ?
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.