Kotlin Academy · Les

Destructurerende declaraties

Pak waarden uit in variabelen

Les 3 van 413 stappen

Destructurerende declaraties is een gratis Kotlin Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Objecten uitpakken

Soms wil je meerdere eigenschappen tegelijk uit een object halen.

Met Kotlin-destruction declaraties kun je in één regel meerdere variabelen aan één object toewijzen.

Basis voor destructurering

Zet namen tussen haakjes links van =. Kotlin wijst de componenten van het object er in volgorde aan toe.

Dataklassen ondersteunen dit automatisch.

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

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

Hoe het werkt

Achter de schermen roept destructurering de gegenereerde component1(), component2() enzovoort aan.

De positie van elke variabele komt overeen met de bijbehorende componentfunctie.

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

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

De volgorde is belangrijk

Variabelen worden gekoppeld op basis van hun positie, niet op basis van hun naam.

De eerste variabele krijgt altijd de eerste eigenschap van de constructor, ongeacht welke naam je eraan geeft.

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
}

Componenten overslaan

Gebruik een onderstrepingsteken _ om een component over te slaan die je niet nodig hebt.

Zo blijft je code overzichtelijk wanneer slechts enkele waarden van belang zijn.

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)
}

Destructurering in lussen

Destructurering komt goed van pas wanneer je door verzamelingen objecten loopt.

Je kunt elk element rechtstreeks in de kop van de for-lus uitpakken.

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)
    }
}

Map-items destructureren

Maps ondersteunen destructurering omdat hun items componenten voor de sleutel en waarde leveren.

Zo wordt itereren over een map erg leesbaar.

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

Meerdere waarden teruggeven

Een functie kan een dataklasse teruggeven, waarna de aanroeper het resultaat kan destructureren.

Dit is een schoon alternatief voor uitvoerparameters.

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)
}

Pair en Triple destructureren

De standaardbibliotheek ondersteunt ook destructurering voor Pair en Triple.

Ze zijn handig om snel waarden te groeperen zonder een klasse te definiëren.

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

Parameters van lambdas destructureren

Je kunt parameters rechtstreeks in de parameterlijst van een lambda destructureren.

Dit komt vaak voor wanneer je over items of paren mapt.

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

Alles samenbrengen

Met destructurering pak je objecten uit in variabelen:

Gebruik haakjes links van =
Componenten worden gekoppeld op basis van hun positie
Sla componenten over met _
Dit werkt in lussen, lambdas en retourwaarden

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

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

Korte controle

Test je begrip van destructureringsdeclaraties.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt destructureringsdeclaraties geleerd:

Ze pakken een object uit in meerdere variabelen
De koppeling gebeurt op basis van positie via componentN()
Met _ sla je ongewenste componenten over
Ze werken in lussen, maps, lambdas en retourwaarden

Vervolgens gebruik je dataklassen in verzamelingen zoals sets en maps.

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Destructurerende declaraties” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Destructurerende declaraties”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Destructurerende declaraties”?

Pak waarden uit in variabelen Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Destructurerende declaraties”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Kotlin Academy