Scala correspondência de padrão

Scala fornece um padrão poderoso mecanismo de correspondência, é também amplamente utilizado.

Um padrão correspondente contém uma série de alternativas, cada um dos quais começa com umcaso de palavras-chave.Cada um contém uma opção de backup e um padrão a uma pluralidade de expressões. Seta símbolo=> separa os padrões e expressões.

O que se segue é um exemplo simples valor inteiro padrão de correspondência:

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

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
many

coincidir com o Java correspondente no interruptor, mas escrito após a expressão selector.A saber: Selector jogo {} alternativas.

Por decisão de expressões para coincidir com o código escrito para tentar cada modo para completar o cálculo, se eles acham que há um caso de correspondência, combinando com o resto do caso, não vai continuar.

Em seguida olhamos para um tipo de correspondência de padrões 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"
   }
}

Implementação do código acima, a saída é:

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

Os exemplos do primeiro caso corresponde a um valor inteiro de 1, o segundo caso corresponde ao valor de cadeia de dois, o segundo caso corresponde ao valor de cadeia de dois, o terceiro caso corresponde ao tipo de modelo utilizado para determinar se o valor transmitido em conjunto tipo, use isInstanceOf comparação para determinar o tipo, padrão de correspondência é melhor. O quarto caso indica as alternativas full-jogo padrão, ou correspondência não for encontrada no outro jogo, um interruptor semelhante no padrão.

Use Classe Sample

Utilizar a palavra-chave caso é a definição de classe é uma classe de amostra (aulas de caso), classe de exemplo é uma classe especial, otimizado para correspondência de padrão.

O que se segue é um exemplo simples de uma classe de exemplo:

object Test {
   def main(args: Array[String]) {
   	val alice = new Person("Alice", 25)
	val bob = new Person("Bob", 32)
   	val charlie = new Person("Charlie", 32)
   
    for (person <- List(alice, bob, charlie)) {
    	person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   // 样例类
   case class Person(name: String, age: Int)
}

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

Quando você declara uma classe exemplo, o seguinte procedimento ocorre automaticamente:

• Cada construtor de parâmetro estão se tornando val, a menos que explicitamente declarado como var, mas isso não é recomendado;
• Fornecendo aplicar métodos de objetos associados, assim você pode construir objetos não podem usar a nova palavra-chave;
• método de cancelar a aplicação fornecida permite a correspondência de padrão pode trabalhar;
• Gerar toString, iguais, hashCode e método de cópia, a menos que o visor mostra as definições para esses métodos.