Déclarations de destruction à Kotlin

1. Vue d'ensemble

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

Si vous souhaitez en savoir plus sur Kotlin, consultez cet article.

2. Déclarations de destruction

Ce concept consiste à traiter les objets comme un ensemble de variables distinctes.

2.1. Objets

La 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 comme 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 l' opérateur ou que la classe est marquée avec les mots-clés de données .

Pour en savoir plus sur les classes de données dans Kotlin, n'oubliez pas de consulter cet article.

2.2. Types de retour

Les déclarations de destruction peuvent également être utilisées lorsque vous travaillez avec 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 variables a et b se voient attribuer des valeurs renvoyées par les méthodes component1 () et component2 () - qui renvoient les deux premiers éléments d'une collection.

Cependant, dans une carte , les variables seraient respectivement clé et valeur :

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 soulignement au lieu du nom de la variable:

val (_, name, age) = person

Ou, si les champs ne sont pas nécessaires à 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 fonctions componentN 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 une paire 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, consultez nos autres articles tels que Vue d'ensemble de l'API Kotlin Collections et les classes de données déjà mentionnées dans Kotlin .

Et, comme toujours, la mise en œuvre complète de ces exemples peut être trouvée dans notre projet GitHub.