Déclarations déstructurées avec componentN
Décomposez des instances de classes de données en variables à l’aide des fonctions component.
Déclarations déstructurées avec componentN est une leçon Kotlin Academy 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Principes de la déstructuration
Une déclaration de déstructuration décompose un objet en plusieurs variables en une seule étape. Elle utilise les fonctions opératrices componentN().
Déstructurer une classe de données
Les classes de données génèrent automatiquement component1, component2, ... Vous pouvez donc écrire val (a, b) = obj.
data class Point(val x: Int, val y: Int)
fun main() {
val p = Point(3, 5)
val (x, y) = p
println("x=$x, y=$y")
}Déstructurer une paire
Les types de la bibliothèque standard Pair et Triple prennent en charge la déstructuration directement.
fun main() {
val pair = "Ada" to 35
val (name, age) = pair
println("$name is $age")
}Déstructurer un triplet
Triple contient trois valeurs ; déstructurez-le en trois variables.
fun main() {
val rgb = Triple(255, 128, 0)
val (r, g, b) = rgb
println("R=$r G=$g B=$b")
}Déstructuration lors de l’itération d’une map
Les entrées d’une map possèdent component1 (la clé) et component2 (la valeur). Déstructurez-les dans l’en-tête d’une boucle for.
fun main() {
val ages = mapOf("Alice" to 30, "Bob" to 25)
for ((name, age) in ages) {
println("$name -> $age")
}
}Déstructuration dans les lambdas
Les lambdas qui acceptent des paires peuvent déstructurer directement leurs paramètres.
fun main() {
val pairs = listOf("a" to 1, "b" to 2, "c" to 3)
pairs.forEach { (letter, num) -> println("$letter=$num") }
}Ignorer des valeurs avec _
Utilisez le caractère de soulignement _ pour ignorer les valeurs dont vous n’avez pas besoin.
data class User(val name: String, val email: String, val age: Int)
fun main() {
val u = User("Ada", "ada@example.com", 35)
val (name, _, age) = u
println("$name ($age)")
}Renvoyer plusieurs valeurs
Une fonction peut renvoyer un Pair ou une classe de données personnalisée ; l’appelant effectue la déstructuration.
data class Result(val sum: Int, val product: Int)
fun computeBoth(a: Int, b: Int) = Result(a + b, a * b)
fun main() {
val (s, p) = computeBoth(4, 5)
println("sum=$s product=$p")
}componentN personnalisé
N’importe quelle classe peut prendre en charge la déstructuration en déclarant operator fun componentN().
class RGB(val r: Int, val g: Int, val b: Int) {
operator fun component1() = r
operator fun component2() = g
operator fun component3() = b
}
fun main() {
val (red, green, blue) = RGB(255, 100, 0)
println("$red $green $blue")
}Déstructuration avec withIndex()
Obtenez la paire composée de l’index et de la valeur lors de l’itération avec withIndex().
fun main() {
val fruits = listOf("apple", "banana", "cherry")
for ((idx, fruit) in fruits.withIndex()) {
println("$idx: $fruit")
}
}Limitation : fondée sur la position
La déstructuration se fait par position, et non par nom. Réordonner les champs d’une classe de données modifie silencieusement la signification aux points d’appel.
data class Point(val x: Int, val y: Int)
fun main() {
val p = Point(10, 20)
val (a, b) = p // a=x, b=y
// Add a property in the middle and old destructuring shifts!
println("$a $b")
}Vérification rapide
Quelle fonction opératrice permet de déstructurer la propriété i-ième ?
Récapitulatif
La déstructuration utilise les fonctions opératrices componentN(). Les classes de données, Pair, Triple et les entrées de map la prennent en charge directement. Utilisez _ pour ignorer des valeurs et retenez que la déstructuration se fait par position, et non par nom.
Questions Fréquemment Posées
La leçon « Déclarations déstructurées avec componentN » est-elle gratuite ?
Oui — le texte complet de « Déclarations déstructurées avec componentN » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Déclarations déstructurées avec componentN » ?
Décomposez des instances de classes de données en variables à l’aide des fonctions component. Tu pratiques Kotlin Academy 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 Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy 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 « Déclarations déstructurées avec componentN » ?
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 Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy 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
- Notions de base des classes de données : méthodes générées automatiquement
- Copier avec copy() et redéfinitions partielles
- Déclarations déstructurées avec componentN
- Classes de données dans les collections et comme clés de map