Domänen kombinieren
Größere Modelle erstellen
Domänen kombinieren 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.
Größere Modelle erstellen
Echte Domänen werden aus kleineren Bausteinen zusammengesetzt. Domänen zu komponieren bedeutet, gut modellierte ADTs, newtypes und validierte Werte zu größeren, weiterhin korrekten Strukturen zu kombinieren.
- Kleine, fokussierte Typen lassen sich zu größeren zusammensetzen.
- Jeder Baustein bewahrt seine eigenen Invarianten.
case class Money(cents: Long)
case class Product(name: String, price: Money)
object Main:
def main(args: Array[String]): Unit =
println(Product("Book", Money(1999)))Produkte verschachteln
Komponieren Sie Produkttypen, indem Sie case classes verschachteln. Jede Ebene fügt Struktur hinzu und bleibt dabei lesbar.
case class Address(city: String, zip: String)
case class Customer(name: String, address: Address)
object Main:
def main(args: Array[String]): Unit =
val c = Customer("Ada", Address("London", "E1"))
println(c.address.city)Mit Collections komponieren
Verwenden Sie List, Map und Set, um Eins-zu-viele-Beziehungen innerhalb Ihrer Domäne zu modellieren.
case class Item(name: String, qty: Int)
case class Order(id: Int, items: List[Item])
object Main:
def main(args: Array[String]): Unit =
val order = Order(1, List(Item("pen", 2), Item("ink", 1)))
println(order.items.map(_.qty).sum)Summ类型 komponieren
Größere Auswahlmöglichkeiten setzen sich aus kleineren zusammen. Eine enum-Variante kann selbst ein weiteres ADT enthalten und so Entscheidungen schichten.
enum Payment:
case Card(last4: String)
case Cash
enum Checkout:
case Completed(payment: Payment)
case Abandoned
object Main:
def main(args: Array[String]): Unit =
val c: Checkout = Checkout.Completed(Payment.Card("1234"))
println(c)Funktionen, die Domänen komponieren
Domänenoperationen sind reine Funktionen, die Eingabetypen in Ausgabetypen überführen. Durch ihre Komposition entstehen Workflows.
case class Cart(total: Long)
case class Receipt(total: Long, tax: Long)
object Main:
def checkout(c: Cart): Receipt =
Receipt(c.total, (c.total * 0.2).toLong)
def main(args: Array[String]): Unit =
println(checkout(Cart(1000)))Validierungen komponieren
Wenn jedes Feld mithilfe eines Smart Constructors erstellt wird, können Sie sie mit einer for-Comprehension kombinieren. Das gesamte Objekt wird nur erstellt, wenn jeder Teil die Validierung besteht.
object V:
def name(s: String): Option[String] = if s.nonEmpty then Some(s) else None
def age(n: Int): Option[Int] = if n >= 0 then Some(n) else None
case class Person(name: String, age: Int)
object Main:
def make(n: String, a: Int): Option[Person] =
for nm <- V.name(n); ag <- V.age(a) yield Person(nm, ag)
def main(args: Array[String]): Unit =
println(Main.make("Bob", 30))
println(Main.make("", 30))Zusammengesetzte Daten falten
Aggregieren Sie zusammengesetzte Strukturen mit fold oder mit map plus sum. Die Form der Daten gibt die Berechnung vor.
case class Line(price: Long, qty: Int)
case class Invoice(lines: List[Line])
object Main:
def total(inv: Invoice): Long =
inv.lines.foldLeft(0L)((acc, l) => acc + l.price * l.qty)
def main(args: Array[String]): Unit =
val inv = Invoice(List(Line(100, 2), Line(50, 4)))
println(total(inv))Unveränderliche Modelle aktualisieren
Komponieren Sie Änderungen mit copy. Diese Methode gibt einen neuen Wert zurück, in dem ausgewählte Felder ersetzt wurden. Das Original bleibt unverändert.
case class Account(id: Int, balance: Long)
object Main:
def deposit(a: Account, amt: Long): Account =
a.copy(balance = a.balance + amt)
def main(args: Array[String]): Unit =
val a = Account(1, 100)
println(deposit(a, 50))Eine Zustandsmaschine modellieren
Komponieren Sie Summentypen und Übergangsfunktionen, um eine Zustandsmaschine zu modellieren, in der nur zulässige Übergänge existieren.
enum Light:
case Red, Green, Yellow
object Main:
def next(l: Light): Light = l match
case Light.Red => Light.Green
case Light.Green => Light.Yellow
case Light.Yellow => Light.Red
def main(args: Array[String]): Unit =
println(next(Light.Red))
println(next(Light.Green))Domäne und Operationen schichten
Halten Sie Datentypen rein und legen Sie das Verhalten in Funktionen oder Methoden ab. Ein komponiertes Modell bildet zusammen mit einer Reihe von Transformationen eine kleine Domänenbibliothek.
case class Temp(celsius: Double):
def toF: Double = celsius * 9 / 5 + 32
object Main:
def main(args: Array[String]): Unit =
val t = Temp(25.0)
println(t.toF)Alles zusammenführen
Ein vollständiges Modell komponiert newtypes, Produkte, Summen, Collections und validierte Konstruktion. Das Ergebnis lässt sich nur schwer falsch verwenden und leicht nachvollziehen.
- Erstellen Sie zuerst kleine Typen.
- Setzen Sie sie zu Aggregaten zusammen.
- Drücken Sie Operationen als reine Funktionen aus.
case class Sku(value: String)
case class Line(sku: Sku, qty: Int)
case class Basket(lines: List[Line]):
def count: Int = lines.map(_.qty).sum
object Main:
def main(args: Array[String]): Unit =
val b = Basket(List(Line(Sku("A"), 2), Line(Sku("B"), 3)))
println(b.count)Kurzer Check
Testen Sie Ihr Verständnis vom Komponieren von Domänen.
Zusammenfassung
Sie haben gelernt, Domänen zu komponieren.
- Verschachteln Sie Produkte und Summen, um umfangreiche Strukturen zu modellieren.
- Verwenden Sie Collections für Eins-zu-viele-Beziehungen.
- Komponieren Sie Validierungen mit
for-Comprehensions. - Aktualisieren Sie unveränderlich mit
copy. - Halten Sie Daten rein und drücken Sie Operationen als Funktionen aus.
case class User(id: Int, name: String)
case class Post(author: User, text: String)
object Main:
def main(args: Array[String]): Unit =
val p = Post(User(1, "Ada"), "hello")
println(p.copy(text = "hi"))
Lerne Scala mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 39
- Lektionen
- 143
Häufig gestellte Fragen
Ist die Lektion „Domänen kombinieren“ kostenlos?
Ja — der vollständige Text von „Domänen kombinieren“ 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 „Domänen kombinieren“?
Größere Modelle erstellen 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 „Domänen kombinieren“?
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.
Alle Lektionen in diesem Kurs
- Modellierung mit ADTs
- Intelligente Konstruktoren
- Newtypes
- Domänen kombinieren