Kotlin Academy · Lekcja

Deklaracje destrukturyzujące

Rozpakowuj wartości do zmiennych

Deklaracje destrukturyzujące 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.

Rozpakowywanie obiektów

Czasami chcą Państwo jednocześnie pobrać kilka właściwości z obiektu.

Deklaracje destrukturyzujące Kotlina pozwalają przypisać wiele zmiennych na podstawie jednego obiektu w jednym wierszu.

Podstawowa destrukturyzacja

Należy umieścić nazwy w nawiasach po lewej stronie znaku =. Kotlin przypisze do nich komponenty obiektu w odpowiedniej kolejności.

Klasy danych obsługują to automatycznie.

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

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

Jak to działa

Za kulisami destrukturyzacja wywołuje wygenerowane funkcje component1(), component2() i kolejne.

Pozycja każdej zmiennej odpowiada pasującej funkcji komponentu.

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

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

Kolejność ma znaczenie

Zmienne są dopasowywane według pozycji, a nie nazwy.

Pierwsza zmienna zawsze otrzymuje pierwszą właściwość konstruktora, niezależnie od nadanej jej nazwy.

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
}

Pomijanie komponentów

Za pomocą podkreślenia _ można pominąć niepotrzebny komponent.

Dzięki temu kod pozostaje przejrzysty, gdy znaczenie mają tylko niektóre wartości.

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

Destrukturyzacja w pętlach

Destrukturyzacja jest szczególnie przydatna podczas iterowania po kolekcjach obiektów.

Każdy element można rozpakować bezpośrednio w nagłówku pętli for.

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

Destrukturyzacja wpisów mapy

Mapy obsługują destrukturyzację, ponieważ ich wpisy udostępniają komponenty klucza i wartości.

Dzięki temu iterowanie po mapie jest bardzo czytelne.

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

Zwracanie wielu wartości

Funkcja może zwrócić klasę danych, a kod wywołujący może przeprowadzić destrukturyzację wyniku.

Jest to przejrzysta alternatywa dla parametrów wyjściowych.

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

Destrukturyzacja Pair i Triple

Elementy biblioteki standardowej Pair i Triple również obsługują destrukturyzację.

Są przydatne do szybkiego grupowania danych bez definiowania klasy.

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

Destrukturyzacja parametrów lambdy

Destrukturyzację można przeprowadzić bezpośrednio na liście parametrów lambdy.

Jest to częste podczas mapowania wpisów lub par.

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

Połączenie wszystkiego

Destrukturyzacja rozpakowuje obiekty do zmiennych:

Po lewej stronie = należy użyć nawiasów
Komponenty są dopasowywane według pozycji
Komponent można pominąć za pomocą _
Działa w pętlach, lambdach i wartościach zwracanych

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

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

Szybki test

Sprawdź swoje rozumienie deklaracji destrukturyzujących.

Podsumowanie

Zapoznałeś się z deklaracjami destrukturyzującymi:

Rozpakowują obiekt do wielu zmiennych
Dopasowanie odbywa się według pozycji za pośrednictwem componentN()
_ pomija niepotrzebne komponenty
Działają w pętlach, mapach, lambdach i wartościach zwracanych

Następnie użyjesz klas danych w kolekcjach, takich jak zbiory i mapy.

Często zadawane pytania

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

Tak — pełny tekst „Deklaracje destrukturyzujące” 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”?

Rozpakowuj wartości do zmiennych Ć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”?

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

← Powrót do Kotlin Academy