Scala | Pattern Matching - GeeksforGeeks

17 Jan, 2019
Pattern matching is a way of checking the given sequence of tokens for the presence of the specific pattern. It is the most widely used feature in Scala. It is a technique for checking a value against a pattern. It is similar to the switch statement of Java and C.
Here, “match” keyword is used instead of switch statement. “match” is always defined in Scala’s root class to make its availability to the all objects. This can contain a sequence of alternatives. Each alternative will start from case keyword. Each case statement includes a pattern and one or more expression which get evaluated if the specified pattern gets matched. To separate the pattern from the expressions, arrow symbol(=>) is used.
Example 1:
// Scala program to illustrate // the pattern matching  object GeeksforGeeks {            // main method      def main(args: Array[String]) {              // calling test method      println(test(1));      }       // method containing match keyword   def test(x:Int): String = x match {                // if value of x is 0,       // this case will be executed       case 0 => "Hello, Geeks!!"                // if value of x is 1,        // this case will be executed       case 1 => "Are you learning Scala?"                // if x doesnt match any sequence,       // then this case will be executed       case _ => "Good Luck!!"   }}
Output:
Are you learning Scala?

Explanation: In the above program, if the value of x which is passed in test method call matches any of the cases, the expression within that case is evaluated. Here we are passing 1 so case 1 will be evaluated. case_ => is the default case which will get executed if value of x is not 0 or 1.
Example 2:
// Scala program to illustrate // the pattern matching   object GeeksforGeeks {             // main method      def main(args: Array[String]) {               // calling test method      println(test("Geeks"));      }         // method containing match keyword   def test(x:String): String = x match {                 // if value of x is "G1",       // this case will be executed       case "G1" => "GFG"                 // if value of x is "G2",        // this case will be executed       case "G2" => "Scala Tutorials"                 // if x doesnt match any sequence,       // then this case will be executed       case _ => "Default Case Executed"   }}
Output:
Default Case Executed

Important Points:
Each match keyword must have at least one case clause.
The last “_“, is a “catch-all” case, will be executed if none of the cases matches. Cases are also called alternatives.
Pattern matching does not have any break statement.
Pattern matching always returns some value.
Match blocks are expressions, not statements. This means that they evaluate the body of whichever case matches. This is a very important feature of functional programming.
Pattern matching can also be used for value assignment and for comprehension, not only in match block.
Pattern matching allows matching any sort of data with the first match policy.
Each case statement returns a value, and the whole match statement is virtually a function that returns a matched value.
Multiple values can be tested in a single line by using “|“.
Scala
Scala
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Scala Tutorial – Learn Scala with Step By Step Guide
Scala List filter() method with example
Scala Map
Type Casting in Scala
Scala Lists
Scala List contains() method with example
Scala String substring() method with example
Lambda Expression in Scala
Scala String replace() method with example