Scala for Backend Engineering & Functional Programming · Lektion

Typen und Werte abgleichen

Typ-Patterns

Typen und Werte abgleichen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Typmuster

Neben dem Abgleich konkreter Werte kann match anhand des Typs eines Werts verzweigen. Dies wird als Typmuster bezeichnet.

Sie schreiben case x: Type =>. Der Zweig wird ausgeführt, wenn der Wert diesen Typ hat, und bindet ihn an x.

Nach Typ abgleichen

Wenn ein Wert einen allgemeinen Typ wie Any hat, können Sie seinen konkreten Typ mit einem Typmuster ermitteln.

Jeder case x: T prüft den Laufzeittyp.

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

Den gebundenen Wert verwenden

Der gebundene Name hat den abgeglichenen Typ. Daher können Sie die Methoden dieses Typs in dem Zweig sicher aufrufen.

Eine Typumwandlung ist nicht erforderlich: Der Compiler kennt den Typ innerhalb des Falls.

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

Typ und Wert zusammen

Sie können Wertmuster und Typmuster im selben match kombinieren. Wertmuster sind normalerweise spezifischer, daher sollten Sie sie zuerst platzieren.

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

Double und Boolean abgleichen

Typmuster funktionieren für jeden Typ, einschließlich Double, Boolean und Char.

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

Collections nach Typ abgleichen

Sie können auch Containertypen wie List abgleichen. Hier unterscheiden Sie eine Liste von anderen Werten.

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

Ein häufiger Einsatz: Any verarbeiten

Typmuster sind besonders nützlich, wenn eine Funktion Any empfängt und je nach Typ unterschiedlich reagieren muss, etwa beim Logging oder bei der Serialisierung.

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

Die Reihenfolge bleibt wichtig

Wie bei allen Matches werden Typmuster von oben nach unten geprüft. Ein allgemeinerer Typ an erster Stelle kann einen darunterliegenden, spezifischeren Typ verdecken.

Ordnen Sie die Fälle immer vom spezifischsten zum allgemeinsten.

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

Einschränkung durch Type Erasure

Zur Laufzeit werden generische Typparameter gelöscht. Daher sehen List[Int] und List[String] gleich aus. Ein Abgleich mit List[Int] prüft nur, ob es sich um eine List handelt.

Verwenden Sie List[_], um dies ausdrücklich anzugeben und Warnungen zu vermeiden.

Warum Typmuster?

Typmuster ermöglichen Ihnen:

einen allgemeinen Typ ohne Typumwandlung sicher einzugrenzen
heterogene Werte übersichtlich zu verarbeiten
Wertmuster und Guards zu kombinieren

Sie sind ein wichtiger Schritt auf dem Weg zum Abgleich von Case Classes und ADTs.

Alles zusammenführen

Kombinieren Sie Wert- und Typmuster, um gemischte Eingaben zu klassifizieren.

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

Kurze Überprüfung

Testen Sie Ihr Wissen über Typmuster.

Zusammenfassung

Sie haben gelernt, nach Typen abzugleichen:

case x: Type gleicht nach dem Laufzeittyp ab und bindet x
Der gebundene Wert hat den abgeglichenen Typ, daher ist keine Typumwandlung erforderlich
Kombinieren Sie Wert- und Typmuster, mit den spezifischsten zuerst
Generische Parameter werden gelöscht; verwenden Sie daher List[_]

Häufig gestellte Fragen

Ist die Lektion „Typen und Werte abgleichen“ kostenlos?

Ja — der vollständige Text von „Typen und Werte abgleichen“ 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 „Typen und Werte abgleichen“?

Typ-Patterns 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 2 von 4.

Wie lange dauert die Lektion „Typen und Werte abgleichen“?

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

← Zurück zu Scala for Backend Engineering & Functional Programming