El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Coincidència de Patrons

Següent ►
►

La coincidència de patrons (pattern matching) és una característica poderosa i versàtil de Scala que permet descompondre estructures de dades complexes de manera clara i concisa. És similar a un switch en altres llenguatges de programació, però molt més potent i flexible.

Conceptes Clau

  1. Sintaxi Bàsica: La coincidència de patrons es realitza amb l'expressió match seguida de casos (case).
  2. Patrons: Els patrons poden ser literals, variables, constructors, tuples, llistes, etc.
  3. Guardes: Condicions addicionals que es poden afegir als patrons per refinar la coincidència.
  4. Coincidència Exhaustiva: Assegurar-se que tots els casos possibles estan coberts.

Sintaxi Bàsica

La sintaxi bàsica de la coincidència de patrons és la següent:

expr match {
  case pattern1 => result1
  case pattern2 => result2
  case _ => defaultResult
}

Exemple Bàsic

val x: Any = 5

val result = x match {
  case 1 => "one"
  case 2 => "two"
  case 3 => "three"
  case _ => "other"
}

println(result) // Output: other

Patrons Comuns

Literals

val x: Any = "hello"

val result = x match {
  case "hello" => "greeting"
  case "goodbye" => "farewell"
  case _ => "unknown"
}

println(result) // Output: greeting

Variables

val x: Any = 42

val result = x match {
  case i: Int => s"integer: $i"
  case s: String => s"string: $s"
  case _ => "other"
}

println(result) // Output: integer: 42

Constructors

sealed trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal

val pet: Animal = Dog("Rex")

val result = pet match {
  case Dog(name) => s"Dog named $name"
  case Cat(name) => s"Cat named $name"
}

println(result) // Output: Dog named Rex

Tuples

val pair = (1, "one")

val result = pair match {
  case (1, "one") => "matched"
  case _ => "not matched"
}

println(result) // Output: matched

Llistes

val list = List(1, 2, 3)

val result = list match {
  case List(1, 2, 3) => "matched"
  case _ => "not matched"
}

println(result) // Output: matched

Guardes

Les guardes són condicions addicionals que es poden afegir als patrons per refinar la coincidència.

val x: Int = 5

val result = x match {
  case i if i > 0 => "positive"
  case i if i < 0 => "negative"
  case _ => "zero"
}

println(result) // Output: positive

Coincidència Exhaustiva

És important assegurar-se que tots els casos possibles estan coberts per evitar errors en temps d'execució.

sealed trait Option[+A]
case class Some[A](value: A) extends Option[A]
case object None extends Option[Nothing]

val option: Option[Int] = Some(5)

val result = option match {
  case Some(value) => s"Value is $value"
  case None => "No value"
}

println(result) // Output: Value is 5

Exercicis Pràctics

Exercici 1

Escriu una funció que utilitzi la coincidència de patrons per determinar si un nombre és parell o senar.

def evenOrOdd(x: Int): String = {
  x % 2 match {
    case 0 => "even"
    case 1 => "odd"
  }
}

// Prova la funció
println(evenOrOdd(4)) // Output: even
println(evenOrOdd(7)) // Output: odd

Exercici 2

Escriu una funció que utilitzi la coincidència de patrons per descompondre una llista i retornar el seu primer element, si existeix.

def firstElement[A](list: List[A]): Option[A] = {
  list match {
    case head :: _ => Some(head)
    case Nil => None
  }
}

// Prova la funció
println(firstElement(List(1, 2, 3))) // Output: Some(1)
println(firstElement(Nil)) // Output: None

Resum

La coincidència de patrons és una eina poderosa en Scala que permet descompondre i analitzar estructures de dades de manera clara i concisa. Hem vist com utilitzar patrons literals, variables, constructors, tuples i llistes, així com com afegir guardes per refinar la coincidència. També hem après la importància de la coincidència exhaustiva per evitar errors en temps d'execució. Amb aquests coneixements, estàs preparat per utilitzar la coincidència de patrons en els teus projectes Scala.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats