Scala for Backend Engineering & Functional Programming · Lección

Guardas y binding

Condiciones en las coincidencias

Guardas y binding es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué es una guardia?

Una guardia añade una condición booleana a un caso mediante if. El caso solo coincide cuando el patrón encaja y la guardia es verdadera.

Las guardias permiten dividir un único patrón en casos más precisos según el valor.

Añadir una guardia con if

Escriba la guardia después del patrón: case n if n > 0 =>. Si la condición es falsa, la coincidencia continúa con el siguiente caso.

object Main {
  def sign(n: Int): String = n match {
    case x if x > 0 => "positive"
    case x if x < 0 => "negative"
    case _          => "zero"
  }
  def main(args: Array[String]): Unit = {
    println(sign(5))
    println(sign(-3))
    println(sign(0))
  }
}

Vincular y después usar una guardia

La guardia puede hacer referencia al nombre vinculado en el patrón. Así puede comprobar propiedades del valor coincidente.

object Main {
  def fizz(n: Int): String = n match {
    case x if x % 15 == 0 => "FizzBuzz"
    case x if x % 3 == 0  => "Fizz"
    case x if x % 5 == 0  => "Buzz"
    case x                => x.toString
  }
  def main(args: Array[String]): Unit = {
    println(fizz(15))
    println(fizz(9))
    println(fizz(7))
  }
}

Guardias para rangos

Las guardias son perfectas para expresar rangos, algo que los patrones literales no pueden hacer directamente.

object Main {
  def band(score: Int): String = score match {
    case s if s >= 90 => "A"
    case s if s >= 80 => "B"
    case s if s >= 70 => "C"
    case _            => "F"
  }
  def main(args: Array[String]): Unit = {
    println(band(95))
    println(band(83))
    println(band(60))
  }
}

Vinculación de patrones con @

El símbolo @ vincula el valor coincidente completo a un nombre y, al mismo tiempo, permite hacer coincidir su estructura.

Aquí, whole @ pattern significa: hacer coincidir pattern y llamar también whole al valor coincidente.

object Main {
  def main(args: Array[String]): Unit = {
    val x: Any = 7
    val msg = x match {
      case n @ (_: Int) => s"int value is $n"
      case _            => "other"
    }
    println(msg)
  }
}

Vinculación en colecciones

La vinculación con @ resulta especialmente práctica con patrones estructurados, como al capturar una lista completa mientras se examina también su cabeza.

object Main {
  def describe(xs: List[Int]): String = xs match {
    case all @ (first :: _) => s"starts with $first, full = $all"
    case Nil                => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3)))
    println(describe(Nil))
  }
}

Combinar un patrón de tipo y una guardia

Puede combinar un patrón de tipo con una guardia. Primero se comprueba el tipo y después la condición booleana.

object Main {
  def label(x: Any): String = x match {
    case s: String if s.length > 3 => "long string"
    case s: String                 => "short string"
    case _                         => "not a string"
  }
  def main(args: Array[String]): Unit = {
    println(label("hello"))
    println(label("hi"))
    println(label(42))
  }
}

Varias condiciones

Una guardia no es más que una expresión booleana, por lo que puede combinar condiciones con && y ||.

object Main {
  def category(age: Int): String = age match {
    case a if a >= 13 && a <= 19 => "teen"
    case a if a < 13             => "child"
    case _                       => "adult"
  }
  def main(args: Array[String]): Unit = {
    println(category(15))
    println(category(8))
    println(category(40))
  }
}

Las guardias no continúan con el siguiente caso de forma automática

Si un patrón coincide pero su guardia es falsa, Scala pasa al siguiente caso, no a la siguiente guardia del mismo patrón.

Asegúrese de que un caso posterior pueda capturar los valores que no superen ninguna guardia.

object Main {
  def test(n: Int): String = n match {
    case x if x > 100 => "big"
    case x            => s"not big: $x"
  }
  def main(args: Array[String]): Unit = {
    println(test(200))
    println(test(5))
  }
}

¿Por qué usar guardias y vinculación?

Juntas, las guardias y las vinculaciones con @ hacen que la coincidencia de patrones sea expresiva:

Las guardias añaden condiciones como rangos y divisibilidad
@ captura el valor completo mientras lo descompone
Mantienen la lógica de ramificación compacta y legible

Integración

Este ejemplo vincula el valor, comprueba una guardia y proporciona una alternativa.

object Main {
  def temp(c: Int): String = c match {
    case t if t >= 30 => s"hot ($t)"
    case t if t >= 15 => s"mild ($t)"
    case t            => s"cold ($t)"
  }
  def main(args: Array[String]): Unit = {
    println(temp(35))
    println(temp(20))
    println(temp(5))
  }
}

Comprobación rápida

Compruebe su comprensión de las guardias y la vinculación.

Resumen

Ha aprendido a precisar las coincidencias:

Una guardia es una condición if después de un patrón
Si la guardia es falsa, la coincidencia pasa al siguiente caso
El operador @ vincula el valor completo mientras lo descompone
Las guardias se combinan con patrones de tipo y operadores booleanos

Preguntas frecuentes

¿La lección «Guardas y binding» es gratis?

Sí — el texto completo de «Guardas y binding» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Guardas y binding»?

Condiciones en las coincidencias Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Guardas y binding»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming