Scala for Backend Engineering & Functional Programming · Lektion

Guards und Binding

Bedingungen in Matches

Guards und Binding ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 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 ein Guard?

Ein Guard fügt einem Fall mit if eine boolesche Bedingung hinzu. Der Fall passt nur, wenn das Muster passt und der Guard wahr ist.

Mit Guards können Sie ein einzelnes Muster anhand des Werts in feinere Fälle aufteilen.

Einen if-Guard hinzufügen

Schreiben Sie den Guard nach dem Muster: case n if n > 0 =>. Wenn die Bedingung falsch ist, wird mit dem nächsten Fall fortgefahren.

object Main {
  def sign(n: Int): String = n match {
    case x if x > 0 => "positive"
    case x if x < 0 => "negative"
    case _          => "zero"
  }
  def main(args: Array[String]): Unit = {
    println(sign(5))
    println(sign(-3))
    println(sign(0))
  }
}

Erst binden, dann prüfen

Der Guard kann auf den Namen verweisen, den Sie im Muster gebunden haben. So können Sie Eigenschaften des abgeglichenen Werts prüfen.

object Main {
  def fizz(n: Int): String = n match {
    case x if x % 15 == 0 => "FizzBuzz"
    case x if x % 3 == 0  => "Fizz"
    case x if x % 5 == 0  => "Buzz"
    case x                => x.toString
  }
  def main(args: Array[String]): Unit = {
    println(fizz(15))
    println(fizz(9))
    println(fizz(7))
  }
}

Guards für Bereiche

Guards eignen sich hervorragend für Bereiche, die sich mit Literalmustern nicht direkt ausdrücken lassen.

object Main {
  def band(score: Int): String = score match {
    case s if s >= 90 => "A"
    case s if s >= 80 => "B"
    case s if s >= 70 => "C"
    case _            => "F"
  }
  def main(args: Array[String]): Unit = {
    println(band(95))
    println(band(83))
    println(band(60))
  }
}

Musterbindung mit @

Das Symbol @ bindet den gesamten abgeglichenen Wert an einen Namen, während weiterhin seine Struktur abgeglichen wird.

whole @ pattern bedeutet hier: Gleiche pattern ab und nenne den abgeglichenen Wert außerdem whole.

object Main {
  def main(args: Array[String]): Unit = {
    val x: Any = 7
    val msg = x match {
      case n @ (_: Int) => s"int value is $n"
      case _            => "other"
    }
    println(msg)
  }
}

Binden in Collections

Die Bindung mit @ ist besonders praktisch bei strukturierten Mustern, etwa um eine vollständige Liste zu erfassen und gleichzeitig ihren Kopf zu untersuchen.

object Main {
  def describe(xs: List[Int]): String = xs match {
    case all @ (first :: _) => s"starts with $first, full = $all"
    case Nil                => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3)))
    println(describe(Nil))
  }
}

Typmuster und Guard kombinieren

Sie können ein Typmuster mit einem Guard kombinieren. Zuerst wird der Typ geprüft, anschließend die boolesche Bedingung.

object Main {
  def label(x: Any): String = x match {
    case s: String if s.length > 3 => "long string"
    case s: String                 => "short string"
    case _                         => "not a string"
  }
  def main(args: Array[String]): Unit = {
    println(label("hello"))
    println(label("hi"))
    println(label(42))
  }
}

Mehrere Bedingungen

Ein Guard ist einfach ein boolescher Ausdruck. Daher können Sie Bedingungen mit && und || kombinieren.

object Main {
  def category(age: Int): String = age match {
    case a if a >= 13 && a <= 19 => "teen"
    case a if a < 13             => "child"
    case _                       => "adult"
  }
  def main(args: Array[String]): Unit = {
    println(category(15))
    println(category(8))
    println(category(40))
  }
}

Guards fallen nicht durch

Wenn ein Muster passt, sein Guard aber falsch ist, fährt Scala mit dem nächsten Fall fort – nicht mit dem nächsten Guard desselben Musters.

Stellen Sie sicher, dass ein späterer Fall Werte auffangen kann, die an jedem Guard scheitern.

object Main {
  def test(n: Int): String = n match {
    case x if x > 100 => "big"
    case x            => s"not big: $x"
  }
  def main(args: Array[String]): Unit = {
    println(test(200))
    println(test(5))
  }
}

Warum Guards und Bindungen?

Zusammen machen Guards und @-Bindungen Pattern Matching ausdrucksstark:

Guards fügen Bedingungen wie Bereiche und Teilbarkeit hinzu
@ erfasst den gesamten Wert, während er zerlegt wird
Sie halten Verzweigungslogik kompakt und übersichtlich

Alles zusammenführen

Dieses Beispiel bindet den Wert, prüft einen Guard und stellt eine Ausweichmöglichkeit bereit.

object Main {
  def temp(c: Int): String = c match {
    case t if t >= 30 => s"hot ($t)"
    case t if t >= 15 => s"mild ($t)"
    case t            => s"cold ($t)"
  }
  def main(args: Array[String]): Unit = {
    println(temp(35))
    println(temp(20))
    println(temp(5))
  }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis von Guards und Bindungen.

Zusammenfassung

Sie haben gelernt, Abgleiche zu verfeinern:

Ein Guard ist eine if-Bedingung nach einem Muster
Wenn der Guard falsch ist, wird mit dem nächsten Fall fortgefahren
Der Operator @ bindet den gesamten Wert während der Zerlegung
Guards lassen sich mit Typmustern und booleschen Operatoren kombinieren

Häufig gestellte Fragen

Ist die Lektion „Guards und Binding“ kostenlos?

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

Bedingungen in Matches 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 3 von 4.

Wie lange dauert die Lektion „Guards und Binding“?

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