Destructuring declaration — qu'est-ce que c'est, syntaxe et utilisation en Kotlin

Qu'est-ce que destructuring declaration ?

Destructuring declaration (déclaration de déstructuration) est une construction syntaxique de Kotlin qui permet de décomposer une instance de classe en plusieurs variables en une seule expression. Le côté gauche contient une liste de variables entre parenthèses, le côté droit contient l'objet à décomposer. Kotlin appelle automatiquement la fonction componentN() correspondante pour chaque variable, où N est le numéro d'ordre de la variable entre parenthèses.

La déclaration de déstructuration est le plus souvent utilisée avec les data classes. Le compilateur Kotlin génère automatiquement component1(), component2() et ainsi de suite pour chaque data class — en fonction du nombre de propriétés dans le constructeur primaire. Pour les classes régulières sans le modificateur data, les componentN() ne sont pas générés, mais peuvent être définis manuellement comme des fonctions opérateur avec le mot-clé operator.

La déclaration de déstructuration est devenue un modèle populaire grâce à sa capacité à simplifier le code lors du travail avec des collections de paires, des résultats de fonctions et l'itération de Map. Au lieu d'écrire person.firstName, person.lastName, le développeur écrit val (firstName, lastName) = person. Cela réduit le nombre de lignes et améliore la lisibilité, en particulier dans les boucles et les lambdas.

Comment fonctionne la déstructuration en Kotlin ?

Lors de la rencontre de la construction val (a, b) = obj, le compilateur Kotlin génère le code suivant : val a = obj.component1(); val b = obj.component2(). Si les variables sont déclarées avec var, des assignations var sont générées. Le type de chaque variable est déduit du type de retour de la fonction componentN() correspondante. Cela signifie que la déclaration de déstructuration est totalement type-safe et vérifiée à la compilation.

data class Person(val firstName: String, val lastName: String, val age: Int)

fun main() {
    val person = Person("Alice", "Smith", 30)

    // Déstructuration : component1(), component2(), component3()
    val (firstName, lastName, age) = person
    println("$firstName $lastName, $age ans")
}

Dans le listing, Person est une data class avec trois propriétés. Kotlin génère component1() → firstName, component2() → lastName, component3() → age. L'expression val (firstName, lastName, age) = person appelle ces fonctions et assigne les résultats. Important : les noms de variables n'ont pas besoin de correspondre aux noms de propriétés — le compilateur ne regarde que l'ordre des componentN() et leurs types. Vous ne pouvez décomposer que les N premières propriétés, en ignorant le reste.

Déstructuration des data classes et des types standard

Les data classes sont les principaux candidats pour la déclaration de déstructuration. Chaque data classe obtient automatiquement componentN() pour toutes les propriétés du constructeur primaire. L'ordre des componentN() correspond à l'ordre de déclaration des propriétés. Cela signifie que lorsque vous modifiez l'ordre des champs dans une data class, l'ordre des variables dans la déstructuration change également — ce qui peut entraîner des bugs subtils.

// Déstructuration de Pair
val pair = Pair("key", 42)
val (key, value) = pair
println("$key -> $value")

// Déstructuration de Triple
val triple = Triple("A", "B", "C")
val (first, second, third) = triple

// Map.Entry en boucle
val map = mapOf("a" to 1, "b" to 2)
for ((k, v) in map) {
    println("$k = $v")
}

Pair et Triple sont des classes standard avec déstructuration intégrée pour deux et trois composants. Pair est souvent utilisé comme type de retour pour les fonctions qui doivent renvoyer deux valeurs liées sans créer une data class séparée. Dans une boucle for sur Map.Entry, la construction (k, v) = entry déstructure la clé et la valeur via component1() et component2(). C'est le modèle standard pour itérer sur une Map en Kotlin, remplaçant complètement les appels explicites à key et value.

Trait de soulignement pour les variables inutilisées

Si certains composants ne sont pas nécessaires lors de la déstructuration, Kotlin permet de les remplacer par un trait de soulignement _. Cela améliore la lisibilité — le lecteur voit immédiatement que le composant est ignoré. De plus, l'utilisation de _ empêche l'accès accidentel à une variable non initialisée : le compilateur ne crée aucune variable pour _, éliminant les avertissements concernant les variables inutilisées.

data class Order(
    val id: Long,
    val customerName: String,
    val amount: Double,
    val status: String
)

fun process(orders: List<Order>) {
    for ((id, _, amount) in orders) {
        println("Commande $id : $amount")
    }
}

Dans le listing, Order a quatre propriétés, mais la boucle a seulement besoin de id et amount. Le trait de soulignement à la place de customerName indique au compilateur « saute component2() ». Kotlin n'appelle pas component2() et ne crée pas de variable pour ce composant. Important : les traits de soulignement ne peuvent être utilisés que dans les déclarations de déstructuration, pas dans le constructeur de data class. Si plusieurs composants consécutifs sont sautés, chacun reçoit son propre trait de soulignement.

Création de componentN() pour les classes personnalisées

Pour les classes sans le modificateur data, vous pouvez définir manuellement componentN() en ajoutant le mot-clé operator. Cela permet d'utiliser la déclaration de déstructuration avec n'importe quelle classe, y compris les classes tierces dont le code source ne peut pas être modifié — écrivez simplement une fonction d'extension avec operator. Cette approche est particulièrement utile pour les classes de bibliothèques et les classes Java qui n'ont pas de componentN() automatiques.

class Rect(val width: Int, val height: Int)

operator fun Rect.component1(): Int = width
operator fun Rect.component2(): Int = height

// Pour une classe Java avec getters
operator fun Dimension.component1(): Int = width
operator fun Dimension.component2(): Int = height

fun main() {
    val rect = Rect(1920, 1080)
    val (w, h) = rect
    println("Résolution : ${w}x${h}")
}

Dans l'exemple, Rect est une classe régulière sans data. Les fonctions d'extension avec operator fun component1() = width et component2() = height ajoutent la prise en charge de la déstructuration. De même pour java.awt.Dimension : une extension operator sur Dimension permet de le décomposer en width et height. Limitation : le nombre maximum de composants pour une déclaration de déstructuration est de 5. En théorie, vous pouvez définir component6() et au-delà, mais Kotlin ne générera pas la syntaxe correspondante pour 6+ variables entre parenthèses.