streamalism.org

1. Overzicht

In deze tutorial introduceren we het concept van Destructuring Declarations in Kotlin, en bekijken we hoe het kan worden gebruikt.

Lees dit artikel als je meer wilt weten over Kotlin.

2. Verklaringen betreffende vernietiging

Dit concept bestaat uit het behandelen van objecten als een reeks afzonderlijke variabelen.

2.1. Voorwerpen

Het kan handig zijn om een ​​object in meerdere variabelen te vernietigen:

val person = Persoon (1, "Jon Snow", 20) val (id, naam, leeftijd) = persoon 

Hiermee hebben we drie nieuwe variabelen gemaakt:

println (id) // 1 println (naam) // Jon Snow println (leeftijd) // 20 

Een vernietigingsverklaring wordt opgesteld als de volgende code:

val id = person.component1 (); val naam = person.component2 (); val leeftijd = person.component3 ();

Om de vernietigingsverklaring te gebruiken, moeten we ervoor zorgen dat de component is gemarkeerd met de operator of de klas is gemarkeerd met de gegevens trefwoorden.

Voor meer informatie Dataklassen in Kotlin, vergeet niet te checken dit artikel.

2.2. Retourtypen

Destructureringsaangiften kunnen ook worden gebruikt bij het werken met retourwaarden:

fun getPersonInfo () = Persoon (2, "Ned Stark", 45) val (id, naam, leeftijd) = getPersonInfo ()

Of laten we zeggen dat we twee waarden van een functie moeten retourneren:

fun twoValuesReturn (): Pair {// ... return Pair (1, "success")} val (resultaat, status) = twoValuesReturn ()

2.3. Collecties en For-loops

Een verzameling herhalen met for-loops kan als volgt worden gedaan met vernietigingsverklaringen:

voor ((a, b) in verzameling) {...} 

De variabelen een en b krijgen waarden toegewezen die worden geretourneerd door component1 () en component2 () methoden - die de eerste twee elementen in een verzameling retourneren.

In een Kaart, de variabelen zouden zijn sleutel en waarde, respectievelijk:

var map: HashMap = HashMap () map.put (1, person) for ((key, value) in map) {println ("Key: $ key, Value: $ value")}

2.4. Onderstreping en vernietiging in Lambdas

In het geval dat we niet alle waarden nodig hebben die zijn verkregen in een vernietigingsverklaring, kunnen we een onderstrepingsteken gebruiken in plaats van de variabelenaam:

val (_, naam, leeftijd) = persoon

Of, als niet benodigde velden aan het einde staan, kunnen we ze helemaal weglaten:

val (id, naam) = persoon

We kunnen ook de syntaxis van destructurerende declaraties gebruiken voor lambda-parameters, zolang het een type is met de juiste componentN functies:

map.mapValues ​​{entry -> "$ {entry.value}!" } map.mapValues ​​{(sleutel, waarde) -> "$ waarde!" }

Let op het verschil tussen het declareren van twee parameters en het declareren van een destructurerend paar:

{a -> ...} // één parameter {a, b -> ...} // twee parameters {(a, b) -> ...} // een gedestructureerd paar {(a, b), c -> ...} // een gedestructureerd paar en een andere parameter

3. Conclusie

In dit korte artikel hebben we Destructuring Declarations in Kotlin benaderd, met zijn vele toepassingen en bijzonderheden.

Voor meer informatie over Kotlin, bekijk zeker onze andere artikelen, zoals Overzicht van Kotlin Collections API en het reeds genoemde Dataklassen in Kotlin.

En, zoals altijd, is de volledige implementatie van deze voorbeelden te vinden in ons GitHub-project.