Déclarations de destruction à Kotlin

1. Vue d'ensemble

Dans ce didacticiel, nous présenterons le concept de déclarations de destruction dans Kotlin et verrons comment il peut être utilisé.

Si vous voulez en savoir plus sur Kotlin, consultezthis article.

2. Déclarations de destruction

Ce concept consiste à traiter les objets comme un ensemble de variables séparées.

2.1. Objets

Destruction d'un objet en plusieurs variables peut être pratique:

val person = Person(1, "Jon Snow", 20)
val(id, name, age) = person

Avec cela, nous avons créé trois nouvelles variables:

println(id)     //1
println(name)   //Jon Snow
println(age)    //20

Une déclaration de déstructuration est compilée sous le code suivant:

val id = person.component1();
val name = person.component2();
val age = person.component3();

Afin d'utiliser la déclaration de déstructuration, nous devons nous assurer que le composant est marqué avec lesoperator ou la classe est marquée avec les mots-clésdata.

Pour en savoir plus surData Classes à Kotlin, n'oubliez pas de consulter l'article dethis.

2.2. Types de retour

Les déclarations de destruction peuvent également être utilisées lorsque vous utilisez des valeurs de retour:

fun getPersonInfo() = Person(2, "Ned Stark", 45)
val(id, name, age) = getPersonInfo()

Ou disons que nous devons renvoyer deux valeurs à partir d'une fonction:

fun twoValuesReturn(): Pair {
    // ...
    return Pair(1, "success")
}

val (result, status) = twoValuesReturn()

2.3. Collections et boucles For

Itérer une collection avec des boucles for peut être fait avec des déclarations de déstructuration, comme ceci:

for ((a, b) in collection) { ... }

Les variablesa etb se voient attribuer des valeurs renvoyées par les méthodescomponent1() etcomponent2() - qui renvoient les deux premiers éléments d'une collection.

Cependant, dans unMap, les variables seraient respectivementkey etvalue,:

var map: HashMap = HashMap()

map.put(1, person)

for((key, value) in map){
    println("Key: $key, Value: $value")
}

2.4. Soulignement et destruction dans les Lambdas

Dans le cas où nous n’avons pas besoin de toutes les valeurs obtenues dans une déclaration de déstructuration, nous pouvons utiliser un trait de soulignement au lieu du nom de la variable:

val (_, name, age) = person

Ou, si les champs non nécessaires sont à la fin, nous pouvons les omettre du tout:

val (id, name) = person

Nous pouvons également utiliser la syntaxe des déclarations de déstructuration pour les paramètres lambda, du moment qu'il s'agit d'un type avec les fonctionscomponentN appropriées:

map.mapValues { entry -> "${entry.value}!" }
map.mapValues { (key, value) -> "$value!" }

Soyez conscient de la différence entre déclarer deux paramètres et déclarer un couple de déstructuration:

{ a -> ... } // one parameter
{ a, b -> ... } // two parameters
{ (a, b) -> ... } // a destructured pair
{ (a, b), c -> ... } // a destructured pair and another parameter

3. Conclusion

Dans cet article rapide, nous avons abordé les déclarations de destruction dans Kotlin, avec ses nombreux usages et particularités.

Pour en savoir plus sur Kotlin, certainement, consultez nos autres articles tels queOverview of Kotlin Collections API et lesData Classes in Kotlin déjà mentionnés.

Et, comme toujours, l'implémentation complète de ces exemples peut être trouvée dans nosGitHub project.

TOC

Déclarations de destruction à Kotlin