Swiftorial Logo
Home
Swift Lessons
Matchups
CodeSnaps
Tutorials
Career
Resources

Introduction to Pattern Matching in Scala

What is Pattern Matching?

Pattern matching is a powerful feature in Scala that allows checking a value against a pattern. It is similar to switch statements in other programming languages but is more powerful and expressive. Pattern matching can deconstruct data structures, making it a versatile tool for developers.

Basic Syntax

The basic syntax of pattern matching in Scala is as follows:

match expression match { case pattern1 => result1 case pattern2 => result2 ... }

Here, the match expression evaluates the value and compares it with the patterns provided in the case statements.

Simple Example

Let's look at a simple example of pattern matching with integers:

Example Code:
val number = 2
number match {
case 1 => "One"
case 2 => "Two"
case 3 => "Three"
case _ => "Unknown"
}

In this example, if number is 2, the output will be "Two". The underscore (_) acts as a wildcard that matches anything not caught by previous cases.

Output: "Two"

Pattern Matching with Data Structures

Pattern matching is particularly useful with data structures like lists and tuples. Here’s an example with a list:

Example Code:
val myList = List(1, 2, 3)
myList match {
case List(1, _, _) => "Starts with 1"
case List(_, 2, _) => "Contains 2"
case _ => "Other"
}

In this case, if myList contains 1 as the first element, it will output "Starts with 1".

Output: "Starts with 1"

Using Guards in Pattern Matching

Guards can be added to cases to add additional conditions. They are specified using the if keyword:

Example Code:
val number = 5
number match {
case n if n < 0 => "Negative"
case n if n == 0 => "Zero"
case n if n > 0 => "Positive"
}

In this example, if number is 5, the output will be "Positive".

Output: "Positive"

Conclusion

Pattern matching in Scala is a powerful feature that simplifies the process of conditional logic and data deconstruction. By using pattern matching, developers can write cleaner and more maintainable code. Whether dealing with simple values or complex data structures, pattern matching provides a robust mechanism to handle various scenarios effectively.