Dekonstruktion
Daten extrahieren
Dekonstruktion ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was ist Dekonstruktion?
Dekonstruktion (auch Destructuring genannt) bedeutet, die Bestandteile einer Datenstruktur direkt in einem Muster zu extrahieren.
Statt Zugriffsmethoden aufzurufen, beschreiben Sie die Form und benennen die gewünschten Bestandteile.
Ein Tupel dekonstruieren
Ein Tupel fasst mehrere Werte zusammen. Sie können sie in einer einzigen Bindung auseinandernehmen, indem Sie Namen in Klammern schreiben.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tupel in match
Sie können ein Tupel innerhalb eines match dekonstruieren und jede Komponente benennen oder abgleichen.
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)))
}
}Den Kopf einer Liste dekonstruieren
Der Operator :: (cons) teilt eine Liste in ihr erstes Element (den Kopf) und den Rest (den Schwanz).
Das Muster head :: tail passt auf jede nicht leere Liste.
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))
}
}Exakte Listenformen abgleichen
Sie können Listen mit einer bestimmten Länge abgleichen, indem Sie ihre Elemente angeben, etwa List(a, b) für genau zwei Elemente.
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)))
}
}Mit Kopf und Schwanz rekursiv arbeiten
Durch die Trennung von Kopf und Schwanz lässt sich eine Liste übersichtlich rekursiv verarbeiten.
Hier summieren wir eine Liste, indem wir den Kopf zur Summe des Schwanzes addieren.
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)))
}
}Verschachtelte Strukturen dekonstruieren
Muster können verschachtelt werden. Sie können gleichzeitig ein Tupel innerhalb einer Liste oder eine Liste innerhalb eines Tupels dekonstruieren.
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")
}
}
}Teile mit _ ignorieren
Verwenden Sie _ für Bestandteile, die Sie nicht benötigen. So konzentrieren sich die Muster auf die tatsächlich benötigten Daten.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Die ersten beiden binden, den Rest behalten
Sie können die ersten Elemente benennen und alles Folgende mit einem Schwanzmuster erfassen.
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")
}
}
}Warum Dekonstruktion?
Dekonstruktion macht den Datenzugriff:
- deklarativ: Sie beschreiben die Form statt einzelner Schritte
- sicher: Die Struktur wird beim Extrahieren geprüft
- kompakt: Mehrere Werte werden in einem Muster gebunden
Mit Case Classes wird sie noch leistungsfähiger.
Alles zusammenführen
Dieses Beispiel dekonstruiert eine Liste von Tupeln und reagiert auf deren Form.
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))))
}
}Kurze Überprüfung
Testen Sie Ihr Verständnis von Dekonstruktion.
Zusammenfassung
Sie haben gelernt, Daten in Mustern zu dekonstruieren:
- Tupel werden mit
(a, b)aufgeteilt - Listen werden mit
head :: tailoder exakten Formen wieList(a, b)aufgeteilt Nilpasst auf die leere Liste- Verwenden Sie
_, um Teile zu ignorieren, und verschachteln Sie Muster für tiefe Strukturen - Die Aufteilung in Kopf und Schwanz ermöglicht übersichtliche Rekursion
Häufig gestellte Fragen
Ist die Lektion „Dekonstruktion“ kostenlos?
Ja — der vollständige Text von „Dekonstruktion“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Dekonstruktion“?
Daten extrahieren Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Dekonstruktion“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.