PricingLoginStart free
Kotlin Academy · Lekcja

Deklaracje destrukturyzujące z componentN

Destrukturyzuj instancje data class do zmiennych za pomocą funkcji component.

Lekcja 3 z 413 kroki

Deklaracje destrukturyzujące z componentN to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Podstawy destrukturyzacji

Deklaracja destrukturyzująca rozpakowuje obiekt do wielu zmiennych w jednym kroku. Wykorzystuje funkcje operatorowe componentN().

Destrukturyzacja data class

Data class automatycznie generuje component1, component2, ... dzięki czemu można napisać 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")
}

Destrukturyzacja Pair

Typy biblioteki standardowej Pair i Triple obsługują destrukturyzację bez dodatkowej konfiguracji.

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

Destrukturyzacja Triple

Triple przechowuje trzy wartości; można je rozpakować do trzech zmiennych.

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

Destrukturyzacja podczas iteracji po mapie

Elementy mapy mają component1 (klucz) i component2 (wartość). Destrukturyzację można wykonać w nagłówku pętli for.

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

Destrukturyzacja w lambdach

Parametry lambd przyjmujących pary można destrukturyzować bezpośrednio.

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

Pomijanie wartości za pomocą _

Użyj podkreślenia _, aby pominąć niepotrzebne wartości.

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

Zwracanie wielu wartości

Funkcja może zwracać Pair lub własną data class; wywołujący wykonuje destrukturyzację.

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

Własne componentN

Dowolna klasa może obsługiwać destrukturyzację, deklarując 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")
}

Destrukturyzacja za pomocą withIndex()

Podczas iteracji z użyciem withIndex() otrzymujesz parę zawierającą indeks i wartość.

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

Ograniczenie: zależność od pozycji

Destrukturyzacja odbywa się według pozycji, a nie nazwy. Zmiana kolejności pól data class po cichu zmienia znaczenie w miejscach wywołania.

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

Szybkie sprawdzenie

Która funkcja operatorowa umożliwia destrukturyzację i-tej właściwości?
Odpowiedz w interaktywnej lekcji

Podsumowanie

Destrukturyzacja wykorzystuje funkcje operatorowe componentN(). Data class, Pair, Triple i elementy map obsługują ją bez dodatkowej konfiguracji. Użyj _, aby pomijać wartości, i pamiętaj: destrukturyzacja odbywa się według pozycji, a nie nazwy.

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
51
Lekcje
203
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Deklaracje destrukturyzujące z componentN” jest bezpłatna?

Tak — pełny tekst „Deklaracje destrukturyzujące z componentN” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Deklaracje destrukturyzujące z componentN”?

Destrukturyzuj instancje data class do zmiennych za pomocą funkcji component. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Deklaracje destrukturyzujące z componentN”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy data class: automatycznie generowane metody
  2. Kopiowanie za pomocą copy() i częściowe przesłanianie
  3. Deklaracje destrukturyzujące z componentN
  4. Data class w kolekcjach i jako klucze map
← Powrót do Kotlin Academy