Case Matching in Scala: A Powerful Alternative to Java’s Switch
In Scala, the case keyword is used to match values against a pattern, providing a more expressive and flexible alternative to Java’s switch statement. This article explores the syntax and capabilities of Scala’s case matching, showcasing its power and versatility.
Pattern Matching
Pattern matching in Scala is used to specify a set of values that a variable can take. The syntax is similar to Java’s switch statement, but with a more concise and expressive approach. Here’s an example of a simple pattern match:
val pattern = "(s.*)"
val v1 = "spark"
val r = v1 match {
case pattern(v1) => "begin s *"
case "1" => "1"
case "2" => "2"
case _ => "default"
}
println(r) // "begin s *"
In this example, the match keyword is used to specify a set of patterns to match against. The case keyword is used to specify each pattern, and the expression on the right-hand side is executed if the pattern matches.
Equivalence Matching
Scala’s case matching also supports equivalence matching, where two values are considered equal if they are instances of the same class or implement the same trait. Here’s an example of equivalence matching:
val v1 = 1
val r = v1 match {
case 1 => "1"
case 2 => "2"
case 3 => "3"
case _ => "default"
}
println(r) // "1"
In this example, the match keyword is used to specify a set of patterns to match against, and the case keyword is used to specify each pattern. The expression on the right-hand side is executed if the pattern matches.
Range Matching
Scala’s case matching also supports range matching, where a value is matched against a range of values. Here’s an example of range matching:
val v1 = 3
val r = v1 match {
case v1 if (1 until 5 contains v1) => "1-5"
case v1 if (5 until 10 contains v1) => "5-10"
case _ => "not found"
}
println(r) // "1-5"
In this example, the match keyword is used to specify a set of patterns to match against, and the case keyword is used to specify each pattern. The expression on the right-hand side is executed if the pattern matches.
Deformation Syntax
Scala’s case matching also supports deformation syntax, where a value is matched against a more complex pattern. Here’s an example of deformation syntax:
val v1 = 3
val r = v1 match {
case v1 if (v1 > 0 && v1 <= 5) => "1-5"
case v1 if (v1 > 5 && v1 <= 10) => "5-10"
case _ => "not found"
}
println(r) // "1-5"
In this example, the match keyword is used to specify a set of patterns to match against, and the case keyword is used to specify each pattern. The expression on the right-hand side is executed if the pattern matches.
Matching Over Multiple Values
Scala’s case matching also supports matching over multiple values, where a value is matched against a set of possible values. Here’s an example of matching over multiple values:
def glob(x: Any): Any = x match {
case 1 | "1" | "one" => "one"
case "two" => 2
case s: String => "String"
case y: Int => "Int Type"
case _ => "Other"
}
println(glob(4)) // "Int Type"
In this example, the match keyword is used to specify a set of patterns to match against, and the case keyword is used to specify each pattern. The expression on the right-hand side is executed if the pattern matches.
In conclusion, Scala’s case matching provides a powerful and flexible alternative to Java’s switch statement, offering a range of features and capabilities that make it an essential tool for any Scala developer.