Décomposer des tuples
Récupérez les valeurs.
Décomposer des tuples 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.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Getting Values Out
Creating a tuple is only half the story. To use the values inside, you need to take them back out.
Scala gives you two main ways: numbered accessors and pattern destructuring. This lesson covers both.
Accessing by Position
Every tuple element has a position you can read with ._1, ._2, and so on.
Note that positions start at one, not zero. So ._1 is the first element.
val person = ("Alice", 30)
println(person._1)
println(person._2)Using Accessors in Code
Positional accessors are handy when you need just one element.
Here we read the age from a pair and add one to it. Accessors return the original element type, so math works directly.
val record = ("Bob", 42)
val nextYear = record._2 + 1
println(nextYear)Destructuring with val
Reading ._1 and ._2 can get hard to follow. Destructuring lets you name each element at once.
This val pattern binds name and age in a single line.
val (name, age) = ("Cara", 25)
println(name)
println(age)Why Destructuring Helps
Named variables read far better than numbered positions.
Comparing age to person._2, the destructured version makes your intent obvious and avoids off-by-one mistakes.
val (city, population) = ("Lyon", 500000)
println(s"$city has $population people")Destructuring Three Elements
Destructuring works for tuples of any size, not just pairs.
Here a three-element tuple is unpacked into three named variables in one statement.
val (id, label, active) = (7, "task", true)
println(id)
println(label)
println(active)Ignoring With Underscore
Sometimes you only want some of the values. Use an underscore _ to skip a position.
Here we keep just the name and ignore the age completely.
val (name, _) = ("Dana", 40)
println(name)Destructuring Function Results
Functions that return tuples pair naturally with destructuring.
You can name both returned values right where you call the function, making the result self-documenting.
def minMax(a: Int, b: Int) = (a min b, a max b)
val (low, high) = minMax(8, 3)
println(low)
println(high)Swapping a Pair
A two-element tuple has a built-in swap method that flips its elements.
This returns a new pair with the order reversed, which is occasionally handy.
val pair = ("a", 1)
println(pair.swap)Destructuring in for
When looping over a collection of pairs, you can destructure inside the loop header.
Each pair is unpacked into key and value automatically on every iteration.
val pairs = List(("a", 1), ("b", 2))
for ((key, value) <- pairs) println(s"$key=$value")Types Are Preserved
Destructuring never loses type information. Each named variable keeps the exact type of its slot.
So in val (n, age) = ("Eve", 33), n is a String and age is an Int, ready for type-safe use.
val (n, age) = ("Eve", 33)
println(n.length)
println(age * 2)Quick Check
Test what you learned about destructuring tuples.
Recap
You can pull tuple values out with positional accessors like ._1 (one-based) or, more clearly, with destructuring such as val (a, b) = pair.
Underscore skips unwanted slots, destructuring works in for loops, and types are always preserved. Next you will explore ranges.
Questions Fréquemment Posées
La leçon « Décomposer des tuples » est-elle gratuite ?
Oui — le texte complet de « Décomposer des tuples » 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écomposer des tuples » ?
Récupérez les valeurs. 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 « Décomposer des tuples » ?
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
- Créer des tuples
- Décomposer des tuples
- Construire des plages
- Plages dans les boucles