Scala | Pattern Matching

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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!!"
   }
}

chevron_right


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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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"
   }
}

chevron_right


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 “|“.


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.