Kotlin Academy · Leçon

Déclarations par déstructuration

Décomposer en variables

Déclarations par déstructuration 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.

Décomposer des objets

Vous souhaitez parfois extraire plusieurs propriétés d’un objet en une seule fois.

Les déclarations par décomposition de Kotlin vous permettent d’affecter plusieurs variables à partir d’un seul objet sur une seule ligne.

Décomposition de base

Placez les noms entre parenthèses à gauche de =. Kotlin leur affecte les composants de l’objet dans l’ordre.

Les classes de données prennent automatiquement cette fonctionnalité en charge.

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Alice", 30)
    val (name, age) = user
    println(name)
    println(age)
}

Fonctionnement

En coulisse, la déstructuration appelle les fonctions component1(), component2() générées, et ainsi de suite.

La position de chaque variable correspond à la fonction de composant correspondante.

data class Point(val x: Int, val y: Int)

fun main() {
    val p = Point(3, 7)
    println(p.component1())
    println(p.component2())
}

L’ordre compte

Les variables sont associées selon leur position, et non selon leur nom.

La première variable reçoit toujours la première propriété du constructeur, quel que soit le nom que vous lui donnez.

data class Pair2(val first: Int, val second: Int)

fun main() {
    val (a, b) = Pair2(10, 20)
    println(a) // first property
    println(b) // second property
}

Ignorer des composants

Utilisez un trait de soulignement _ pour ignorer un composant dont vous n’avez pas besoin.

Votre code reste ainsi clair lorsque seules certaines valeurs vous intéressent.

data class User(val name: String, val age: Int, val city: String)

fun main() {
    val (name, _, city) = User("Mia", 28, "Paris")
    println(name)
    println(city)
}

Déstructuration dans les boucles

La déstructuration est particulièrement utile lorsque vous parcourez des collections d’objets.

Vous pouvez décomposer chaque élément directement dans l’en-tête de la boucle for.

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(User("A", 20), User("B", 25))
    for ((name, age) in users) {
        println(name + " is " + age)
    }
}

Déstructuration des entrées d’une table associative

Les tables associatives prennent en charge la déstructuration, car leurs entrées fournissent des composants clé et valeur.

Parcourir une table associative devient ainsi très lisible.

fun main() {
    val scores = mapOf("Alice" to 90, "Bob" to 85)
    for ((name, score) in scores) {
        println(name + ": " + score)
    }
}

Retourner plusieurs valeurs

Une fonction peut retourner une classe de données, puis l’appelant peut déstructurer le résultat.

C’est une alternative claire aux paramètres de sortie.

data class MinMax(val min: Int, val max: Int)

fun minMax(nums: List<Int>): MinMax {
    return MinMax(nums.min(), nums.max())
}

fun main() {
    val (low, high) = minMax(listOf(3, 1, 8, 5))
    println(low)
    println(high)
}

Déstructurer une paire et un triplet

La bibliothèque standard Pair et Triple prend également en charge la déstructuration.

Ces types sont pratiques pour regrouper rapidement des valeurs sans définir de classe.

fun main() {
    val pair = Pair("x", 1)
    val (label, value) = pair
    println(label)
    println(value)
}

Déstructuration des paramètres d’une lambda

Vous pouvez déstructurer directement dans la liste des paramètres d’une lambda.

C’est courant lorsque vous appliquez une transformation aux entrées ou aux paires.

fun main() {
    val map = mapOf(1 to "one", 2 to "two")
    val text = map.map { (key, value) -> "" + key + "=" + value }
    println(text)
}

Tout mettre en pratique

La déstructuration décompose les objets en variables :

Utilisez des parenthèses à gauche de =
Les composants sont associés selon leur position
Utilisez _ pour ignorer un composant
Elle fonctionne dans les boucles, les lambdas et les retours

data class Result(val ok: Boolean, val message: String)

fun main() {
    val (ok, message) = Result(true, "done")
    println(ok)
    println(message)
}

Vérification rapide

Vérifiez votre compréhension des déclarations par déstructuration.

Récapitulatif

Vous avez appris les déclarations par déstructuration :

Elles décomposent un objet en plusieurs variables
L’association se fait selon la position grâce à componentN()
_ permet d’ignorer les composants inutiles
Elles fonctionnent dans les boucles, les tables associatives, les lambdas et les retours

Vous allez maintenant utiliser des classes de données dans des collections comme les ensembles et les tables associatives.

Questions Fréquemment Posées

La leçon « Déclarations par déstructuration » est-elle gratuite ?

Oui — le texte complet de « Déclarations par déstructuration » 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 par déstructuration » ?

Décomposer en variables 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 par déstructuration » ?

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

← Retour à Kotlin Academy