Dekonstrukcja
Wyodrębnianie danych
Dekonstrukcja to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 4 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 Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Czym jest dekonstrukcja?
Dekonstrukcja (zwana także destrukturyzacją) oznacza wyodrębnianie części struktury danych bezpośrednio we wzorcu.
Zamiast wywoływać metody dostępowe, opisuje się kształt struktury i nadaje nazwy potrzebnym elementom.
Dekonstrukcja krotki
Krotka grupuje kilka wartości. Można rozdzielić je w ramach jednego przypisania, zapisując nazwy w nawiasach.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Krotki w match
Krotkę można zdekonstruować wewnątrz match, nadając nazwy poszczególnym elementom lub dopasowując je.
object Main {
def quadrant(p: (Int, Int)): String = p match {
case (0, 0) => "origin"
case (x, 0) => s"on x-axis at $x"
case (0, y) => s"on y-axis at $y"
case (x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(quadrant((0, 0)))
println(quadrant((3, 0)))
println(quadrant((2, 5)))
}
}Dekonstrukcja głowy listy
Operator :: (cons) dzieli listę na jej pierwszy element (głowę) oraz resztę (ogon).
Wzorzec head :: tail pasuje do każdej niepustej listy.
object Main {
def first(xs: List[Int]): String = xs match {
case head :: tail => s"head=$head, rest=$tail"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(first(List(10, 20, 30)))
println(first(Nil))
}
}Dopasowywanie list o dokładnym kształcie
Można dopasowywać listy o określonej długości, wymieniając ich elementy, na przykład List(a, b) oznacza dokładnie dwa elementy.
object Main {
def shape(xs: List[Int]): String = xs match {
case List() => "none"
case List(a) => s"one: $a"
case List(a, b) => s"two: $a, $b"
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(shape(List()))
println(shape(List(1)))
println(shape(List(1, 2)))
println(shape(List(1, 2, 3)))
}
}Rekurencja z głową i ogonem
Rozdzielenie głowy i ogona umożliwia przejrzystą rekurencję po liście.
W tym przykładzie sumujemy listę, dodając głowę do sumy ogona.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Dekonstrukcja zagnieżdżonych struktur
Wzorce można zagnieżdżać. Jednocześnie można zdekonstruować krotkę wewnątrz listy lub listę wewnątrz krotki.
object Main {
def main(args: Array[String]): Unit = {
val data = List(("a", 1), ("b", 2))
data match {
case (key, value) :: _ => println(s"first key=$key value=$value")
case Nil => println("empty")
}
}
}Pomijanie części za pomocą _
Użyj _ dla elementów, które Cię nie interesują. Dzięki temu wzorce skupiają się na potrzebnych danych.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Przypisywanie dwóch pierwszych elementów i zachowanie reszty
Można nazwać pierwsze elementy i przechwycić wszystko, co następuje po nich, za pomocą wzorca ogona.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3, 4, 5)
xs match {
case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
case _ => println("too short")
}
}
}Dlaczego dekonstrukcja?
Dekonstrukcja sprawia, że dostęp do danych jest:
- deklaratywny: opisujesz kształt, a nie kolejne kroki
- bezpieczny: struktura jest sprawdzana podczas wyodrębniania danych
- zwięzły: wiele wartości można przypisać w jednym wzorcu
W połączeniu z klasami case staje się jeszcze potężniejsza.
Połączenie elementów
Ten przykład dekonstruuje listę krotek i reaguje na jej kształt.
object Main {
def report(scores: List[(String, Int)]): String = scores match {
case Nil => "no scores"
case (name, pts) :: Nil => s"only $name with $pts"
case (name, pts) :: rest => s"top $name=$pts plus ${rest.size} more"
}
def main(args: Array[String]): Unit = {
println(report(Nil))
println(report(List(("Ann", 90))))
println(report(List(("Ann", 90), ("Bo", 80))))
}
}Szybki test
Sprawdź swoją wiedzę o dekonstrukcji.
Podsumowanie
Nauczyłeś się dekonstruować dane we wzorcach:
- krotki rozdziela się za pomocą
(a, b) - listy rozdziela się za pomocą
head :: taillub dopasowuje do dokładnego kształtu, takiego jakList(a, b) Nildopasowuje pustą listę- używaj
_, aby pomijać części; zagnieżdżaj wzorce dla głębokich struktur - rozdzielanie głowy i ogona umożliwia przejrzystą rekurencję
Często zadawane pytania
Czy lekcja „Dekonstrukcja” jest bezpłatna?
Tak — pełny tekst „Dekonstrukcja” 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 Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Co nauczysz się w „Dekonstrukcja”?
Wyodrębnianie danych Ćwiczysz Scala for Backend Engineering & Functional Programming 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ąć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming 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 4 z 4.
Ile czasu zajmuje lekcja „Dekonstrukcja”?
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 Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming 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.