Scala for Backend Engineering & Functional Programming · Lektion

match-Ausdrücke

Nach Form verzweigen

match-Ausdrücke ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 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 <code>match</code>?

match ist Scalas leistungsfähiges Konstrukt zur Verzweigung. Sie übergeben ihm einen Wert und eine Reihe von case-Mustern; anschließend wird der erste passende Zweig ausgeführt.

Sie können es sich als ausdrucksbasierte, leistungsfähigere Variante einer switch-Anweisung vorstellen.

Grundlegende Syntax

Sie schreiben value match { case pattern => result }. Jeder case definiert ein Muster und den auszuführenden Code, wenn es passt.

Da match ein Ausdruck ist, liefert der gesamte Ausdruck einen Wert zurück.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 2
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
    }
    println(word)
  }
}

Der Platzhalter-Fall

Der Unterstrich _ ist ein Platzhalter, der auf alles passt. Verwenden Sie ihn am Ende als allgemeine Standardoption.

Ohne ihn löst ein nicht passender Wert zur Laufzeit einen MatchError aus.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 9
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    println(word)
  }
}

Strings abgleichen

Muster sind nicht auf Zahlen beschränkt. Sie können direkt auf String-Literale abgleichen.

object Main {
  def main(args: Array[String]): Unit = {
    val cmd = "start"
    val msg = cmd match {
      case "start" => "Starting up"
      case "stop"  => "Shutting down"
      case _       => "Unknown command"
    }
    println(msg)
  }
}

match liefert einen Wert zurück

Da jeder Zweig einen Wert liefert, können Sie das Ergebnis von match einer val zuweisen oder direkt verwenden.

So bleibt Ihr Code übersichtlich und Sie vermeiden veränderliche Variablen.

object Main {
  def main(args: Array[String]): Unit = {
    val light = "red"
    println(s"Action: " + (light match {
      case "red"   => "stop"
      case "green" => "go"
      case _       => "caution"
    }))
  }
}

Fälle kombinieren

Sie können mehrere Werte in einem Fall abgleichen, indem Sie | (das Pipe-Zeichen) verwenden. Alle aufgeführten Werte führen zum selben Zweig.

object Main {
  def main(args: Array[String]): Unit = {
    val day = "Sat"
    val kind = day match {
      case "Sat" | "Sun" => "weekend"
      case _             => "weekday"
    }
    println(kind)
  }
}

match in einer Funktion

Ein häufig verwendetes Muster besteht darin, den gesamten Funktionskörper zu einem einzigen match-Ausdruck zu machen. Das Ergebnis des Abgleichs wird zum Rückgabewert.

object Main {
  def describe(n: Int): String = n match {
    case 0 => "zero"
    case 1 => "one"
    case _ => "other"
  }
  def main(args: Array[String]): Unit = {
    println(describe(0))
    println(describe(5))
  }
}

Den gesamten Wert binden

Im Platzhalter-Fall können Sie den abgeglichenen Wert mit case other => an einen Namen binden. Anschließend können Sie other in diesem Zweig verwenden.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 42
    val result = n match {
      case 0     => "nothing"
      case other => s"got $other"
    }
    println(result)
  }
}

Die Reihenfolge ist wichtig

Die Fälle werden von oben nach unten geprüft, und der erste Treffer gewinnt. Platzieren Sie spezifischere Muster vor allgemeineren.

Ein zu früh platzierter Platzhalter würde die darunterliegenden Fälle verdecken.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 1
    val msg = n match {
      case 1 => "specific one"
      case _ => "anything else"
    }
    println(msg)
  }
}

Warum match verwenden?

Pattern Matching ist zentral für Scala, weil es:

bei Verzweigungen mit mehreren Möglichkeiten übersichtlich bleibt
als Ausdruck einen Wert zurückliefert
sich auf Typen, Datenstrukturen und Guards erweitern lässt
vom Compiler auf Vollständigkeit geprüft werden kann

Alles zusammenführen

Hier sehen Sie einen kleinen Klassifizierer mit Literalen, einem kombinierten Fall und einem Standardfall.

object Main {
  def grade(score: Int): String = score match {
    case 10 | 9 => "excellent"
    case 8 | 7  => "good"
    case _      => "keep trying"
  }
  def main(args: Array[String]): Unit = {
    println(grade(9))
    println(grade(7))
    println(grade(3))
  }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis von match-Ausdrücken.

Zusammenfassung

Sie haben die Grundlagen von match gelernt:

Die Syntax lautet value match { case pattern => result }
_ ist der Platzhalter für alle übrigen Fälle
Werte lassen sich mit | kombinieren
match ist ein Ausdruck, der einen Wert zurückliefert
Die Fälle werden von oben nach unten geprüft; der erste Treffer gewinnt

Häufig gestellte Fragen

Ist die Lektion „match-Ausdrücke“ kostenlos?

Ja — der vollständige Text von „match-Ausdrücke“ 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 „match-Ausdrücke“?

Nach Form verzweigen 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 1 von 4.

Wie lange dauert die Lektion „match-Ausdrücke“?

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