Déconstruction
Extrayez des données
Déconstruction est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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 la déconstruction ?
La déconstruction (également appelée déstructuration) consiste à extraire directement les parties d’une structure de données dans un motif.
Au lieu d’appeler des méthodes d’accès, vous décrivez la forme et nommez les éléments qui vous intéressent.
Déconstruire un tuple
Un tuple regroupe plusieurs valeurs. Vous pouvez les séparer dans une seule liaison en écrivant leurs noms entre parenthèses.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tuples dans une correspondance
Vous pouvez déconstruire un tuple dans un match, en nommant ou en faisant correspondre chacun de ses composants.
object Main {
def quadrant(p: (Int, Int)): String = p match {
case (0, 0) => "origin"
case (x, 0) => s"on x-axis at $x"
case (0, y) => s"on y-axis at $y"
case (x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(quadrant((0, 0)))
println(quadrant((3, 0)))
println(quadrant((2, 5)))
}
}Déconstruire la tête d’une liste
L’opérateur :: (cons) sépare une liste en son premier élément (la tête) et le reste (la queue).
Le motif head :: tail correspond à toute liste non vide.
object Main {
def first(xs: List[Int]): String = xs match {
case head :: tail => s"head=$head, rest=$tail"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(first(List(10, 20, 30)))
println(first(Nil))
}
}Faire correspondre des formes de liste exactes
Vous pouvez faire correspondre des listes d’une longueur précise en indiquant leurs éléments, comme List(a, b) pour exactement deux éléments.
object Main {
def shape(xs: List[Int]): String = xs match {
case List() => "none"
case List(a) => s"one: $a"
case List(a, b) => s"two: $a, $b"
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(shape(List()))
println(shape(List(1)))
println(shape(List(1, 2)))
println(shape(List(1, 2, 3)))
}
}Récursion avec la tête et la queue
Séparer la tête de la queue permet d’effectuer proprement une récursion sur une liste.
Ici, nous calculons la somme d’une liste en ajoutant la tête à la somme de la queue.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Déconstruire des structures imbriquées
Les motifs peuvent être imbriqués. Vous pouvez déconstruire un tuple dans une liste, ou une liste dans un tuple, en une seule fois.
object Main {
def main(args: Array[String]): Unit = {
val data = List(("a", 1), ("b", 2))
data match {
case (key, value) :: _ => println(s"first key=$key value=$value")
case Nil => println("empty")
}
}
}Ignorer des parties avec _
Utilisez _ pour les composants qui ne vous intéressent pas. Les motifs restent ainsi centrés sur les données dont vous avez réellement besoin.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Lier les deux premiers éléments et conserver le reste
Vous pouvez nommer les premiers éléments et capturer tout ce qui suit avec un motif de queue.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3, 4, 5)
xs match {
case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
case _ => println("too short")
}
}
}Pourquoi déconstruire ?
La déconstruction rend l’accès aux données :
- Déclaratif : vous décrivez la forme, et non les étapes
- Sûr : la structure est vérifiée pendant l’extraction
- Concis : plusieurs valeurs sont liées dans un seul motif
Elle devient encore plus puissante avec les classes case.
Mettre tout ensemble
Cet exemple déconstruit une liste de tuples et réagit selon sa forme.
object Main {
def report(scores: List[(String, Int)]): String = scores match {
case Nil => "no scores"
case (name, pts) :: Nil => s"only $name with $pts"
case (name, pts) :: rest => s"top $name=$pts plus ${rest.size} more"
}
def main(args: Array[String]): Unit = {
println(report(Nil))
println(report(List(("Ann", 90))))
println(report(List(("Ann", 90), ("Bo", 80))))
}
}Vérification rapide
Vérifiez votre compréhension de la déconstruction.
Récapitulatif
Vous avez appris à déconstruire des données dans les motifs :
- Les tuples se séparent avec
(a, b) - Les listes se séparent avec
head :: tailou selon des formes exactes commeList(a, b) Nilcorrespond à la liste vide- Utilisez
_pour ignorer des parties ; imbriquez les motifs pour les structures profondes - La séparation tête/queue permet une récursion propre
Questions Fréquemment Posées
La leçon « Déconstruction » est-elle gratuite ?
Oui — le texte complet de « Déconstruction » 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 « Déconstruction » ?
Extrayez des données 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 4 sur 4.
Combien de temps prend la leçon « Déconstruction » ?
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.