PricingLoginStart free
Kotlin Academy · Lektion

Destrukturerande deklarationer med componentN

Dela upp instanser av data class i variabler med component-funktioner.

Lektion 3 av 413 steg

Destrukturerande deklarationer med componentN är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Grunderna i destructuring

En destructuring-deklaration packar upp ett objekt i flera variabler i ett enda steg. Den använder operatorfunktionerna componentN().

Destructuring av en data class

Data classes genererar automatiskt component1, component2, ... så att du kan skriva val (a, b) = obj.

data class Point(val x: Int, val y: Int)
fun main() {
    val p = Point(3, 5)
    val (x, y) = p
    println("x=$x, y=$y")
}

Destructuring av ett Pair

Stdlib-typerna Pair och Triple stöder destructuring direkt.

fun main() {
    val pair = "Ada" to 35
    val (name, age) = pair
    println("$name is $age")
}

Destructuring av en Triple

Triple innehåller tre värden, som kan packas upp i tre variabler.

fun main() {
    val rgb = Triple(255, 128, 0)
    val (r, g, b) = rgb
    println("R=$r G=$g B=$b")
}

Destructuring vid iteration över Map

Map-poster har component1 (nyckel) och component2 (värde). Packa upp dem i huvudet på en for-loop.

fun main() {
    val ages = mapOf("Alice" to 30, "Bob" to 25)
    for ((name, age) in ages) {
        println("$name -> $age")
    }
}

Destructuring i lambdor

Lambdor som tar emot par kan packa upp parametrarna direkt.

fun main() {
    val pairs = listOf("a" to 1, "b" to 2, "c" to 3)
    pairs.forEach { (letter, num) -> println("$letter=$num") }
}

Ignorera värden med _

Använd understreck _ för att hoppa över värden du inte behöver.

data class User(val name: String, val email: String, val age: Int)
fun main() {
    val u = User("Ada", "ada@example.com", 35)
    val (name, _, age) = u
    println("$name ($age)")
}

Returnera flera värden

En funktion kan returnera ett Pair eller en anpassad data class, som anroparen sedan packar upp.

data class Result(val sum: Int, val product: Int)
fun computeBoth(a: Int, b: Int) = Result(a + b, a * b)
fun main() {
    val (s, p) = computeBoth(4, 5)
    println("sum=$s product=$p")
}

Anpassad componentN

Vilken klass som helst kan stödja destructuring genom att deklarera operator fun componentN().

class RGB(val r: Int, val g: Int, val b: Int) {
    operator fun component1() = r
    operator fun component2() = g
    operator fun component3() = b
}
fun main() {
    val (red, green, blue) = RGB(255, 100, 0)
    println("$red $green $blue")
}

Destructuring med withIndex()

Para ihop index och värde när du itererar med withIndex().

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    for ((idx, fruit) in fruits.withIndex()) {
        println("$idx: $fruit")
    }
}

Begränsning: positionsbaserad

Destructuring sker efter position, inte efter namn. Om du ändrar ordningen på data class-fält ändras betydelsen tyst på de platser där de anropas.

data class Point(val x: Int, val y: Int)
fun main() {
    val p = Point(10, 20)
    val (a, b) = p // a=x, b=y
    // Add a property in the middle and old destructuring shifts!
    println("$a $b")
}

Snabb kontroll

Vilken operatorfunktion möjliggör destructuring av den i:te egenskapen?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Destructuring använder operatorfunktioner av typen componentN(). Data classes, Pair, Triple och Map-poster stöder det direkt. Använd _ för att hoppa över värden och se upp: destructuring är positionsbaserad, inte namn­baserad.

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
51
Lektioner
203
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”Destrukturerande deklarationer med componentN” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Destrukturerande deklarationer med componentN”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Destrukturerande deklarationer med componentN”?

Dela upp instanser av data class i variabler med component-funktioner. Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Destrukturerande deklarationer med componentN”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?

Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Grunderna i data class: automatiskt genererade metoder
  2. Kopiering med copy() och partiella överskuggningar
  3. Destrukturerande deklarationer med componentN
  4. Data classes i samlingar och som map-nycklar
← Tillbaka till Kotlin Academy