pattern matching Scala

Scala fornisce un modello potente corrispondenza meccanismo, è anche ampiamente utilizzato.

Un pattern matching contiene una serie di alternative, ciascuna delle quali inizia con uncaso parola chiave.Ciascuno contiene un'opzione di backup e un motivo ad una pluralità di espressioni. Freccia simbolo=> separa i modelli e le espressioni.

Il seguente è un valore intero semplice pattern matching Esempio:

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

L'attuazione del codice di cui sopra, l'output è:

$ scalac Test.scala 
$ scala Test
many

corrispondere al corrispondente Java nello switch, ma scritta dopo l'espressione del selettore.Vale a dire: Selettore partita {} alternative.

Con ordinanza espressioni per abbinare il codice scritto per provare ogni modalità per completare il calcolo, se trovano c'è un caso di corrispondenza, che corrisponde al resto del caso non continuerà.

Prossimo guardiamo a un diverso tipo di dati di pattern matching:

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

L'attuazione del codice di cui sopra, l'output è:

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

Esempi del primo caso corrisponde ad un valore intero di 1, secondo caso corrisponde al valore di stringa di due, il secondo caso corrisponde al valore della stringa di due, il terzo caso corrisponde al tipo di modello utilizzato per determinare se il valore passato in tutta tipo, utilizzare isInstanceOf confronto per determinare il tipo, pattern matching è meglio. Il quarto caso indica il full-partita alternative predefinite, quella partita non si trova in un altro match, un interruttore simile a default.

Utilizzare la classe di esempio

Utilizzare il caso parola chiave è la definizione di classe è una lezione di prova (classi case), lezione di prova è una classe speciale, ottimizzata per il pattern matching.

Quanto segue è un semplice esempio di una classe di esempio:

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

L'attuazione del codice di cui sopra, l'output è:

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

Quando si dichiara una classe di esempio, la seguente procedura avviene automaticamente:

• Ogni costruttore parametro stanno diventando val, se non esplicitamente dichiarato come var, ma questo non è consigliato;
• Fornire applicare metodi di oggetti associati, in modo da poter costruire oggetti non possono utilizzare la nuova parola chiave;
• Metodo unapply fornito consente pattern matching può funzionare;
• Genera toString, è uguale, hashCode e metodo di copia, a meno che il display mostra le definizioni per tali metodi.