Match Pattern do Scala

Scala oferece um mecanismo poderoso de correspondência de padrão, que é amplamente aplicado.

Um padrão de correspondência contém uma série de opções, cada uma começando com a palavra-chave caseCada opção contém um padrão e uma a várias expressões. O sinal de seta => Separa os padrões das expressões.

A seguir está um exemplo simples de correspondência de padrão com valores inteiros:

object Test {
　　　def main(args: Array[String]) {
　　　　　　println(matchTest(3))
　　　}
　　　def matchTest(x: Int): String = x match {
　　　　　　case　1　=> "one"
　　　　　　case　2　=> "two"
　　　　　　case _ => "many"
　　　}
}

Execute o código acima e o resultado será:

$ scalac Test.scala　
$ scala Test
many

match corresponds ao switch no Java, mas é escrito após a expressão do seletor. Ou seja: Selector match {options}.

A expressão match tenta cada padrão na ordem em que está escrito o código para completar a computação, e assim que encontrar um padrão correspondente, os outros padrões não serão mais correspondidos.

Vamos olhar para um exemplo de correspondência de padrão com tipos de dados diferentes:

object Test {
　　　def main(args: Array[String]) {
　　　　　　println(matchTest("two"))
　　　　　　println(matchTest("test"))
　　　　　　println(matchTest(1))
　　　　　　println(matchTest(6))
　　　}
　　　def matchTest(x: Any): Any = x match {
　　　　　　case　1　=> "one"
　　　　　　case "two" =>　2
　　　　　　case y: Int => "scala.Int"
　　　　　　case _ => "many"
　　　}
}

Execute o código acima e o resultado será:

$ scalac Test.scala　
$ scala Test
2
many
one
scala.Int

A primeira case no exemplo corresponde ao valor numérico inteiro 1A segunda case corresponde ao valor de string "two", a terceira case corresponde a um padrão de tipo, usado para determinar se o valor passado é um inteiro, o que é melhor do que usar isInstanceOf para determinar o tipo. A quarta case representa a opção de correspondência geral padrão, ou seja, a opção de correspondência quando não é encontrada nenhuma correspondência para outros padrões, semelhante ao default no switch.

Uso de classes modelo

As definições de classes que usam a palavra-chave case são classes modelo (case classes), que são um tipo especial de classe, otimizada para ser usada em correspondências de padrão.

A seguir está um exemplo simples de classe modelo:

object Test {
　　　def main(args: Array[String]) {
　　　　　　　　val alice = new Person("Alice",　25)
　　　　　　　　val bob = new Pessoa("Bob",　32)
　　　　　　　　val charlie = new Pessoa("Charlie",　32)
　　　
　　　　)-　for (pessoa <
　　　　　　　　Lista(alice, bob, charlie)) {
　　　　　　　　　　　　pessoa match {　25) => println("Olá Alice!")
　　　　　　　　　　　　) => println("Olá Alice!")　32) => println("Olá Bob!")
　　　　　　　　　　　　case Pessoa(nome, idade) =>
　　　　　　　　　　　　　　　println("Idade: "　+　idade　+　"ano, nome: "　+　nome　+　"?")
　　　　　　　　　}
　　　　　　}
　　　}
　　　//　Classe de Exemplo
　　　case class Pessoa(nome: String, idade: Int)
}

Execute o código acima e o resultado será:

$ scalac Test.scala　
$ scala Test
Olá Alice!
Olá Bob!
Idade:　32　ano, nome: Charlie?

No momento da declaração da classe de exemplo, o seguinte processo ocorre automaticamente:

• Cada parâmetro do construtor se torna um val, a menos que seja explicitamente declarado como var, mas não é recomendado fazer isso;

• Fornece o método apply no objeto anexado, então é possível construir objetos sem usar a palavra-chave new;

• Forneça o método unapply para que o match pattern funcione;

• Gere os métodos toString, equals, hashCode e copy, a menos que sejam fornecidas explicitamente as definições desses métodos.