Scala for Backend Engineering & Functional Programming · Lección

Filtrado con if

Guardas en comprehensions

Filtrado con if es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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.

Guardas en for-comprehensions

Dentro de una for-comprehension puede añadir una condición if llamada guarda. Conserva únicamente los elementos que cumplen la condición, igual que filter.

object Main {
  def main(args: Array[String]): Unit = {
    val evens = for (x <- 1 to 10 if x % 2 == 0) yield x
    println(evens)
  }
}

Las guardas se desazucaran como withFilter

Una guarda if cond se reescribe como una llamada a withFilter (una variante diferida de filter).

for (x <- xs if p(x)) yield x
se convierte en xs.withFilter(p).map(x => x)

object Main {
  def main(args: Array[String]): Unit = {
    val sugar = for (x <- List(1, 2, 3, 4) if x > 2) yield x
    val desugared = List(1, 2, 3, 4).withFilter(_ > 2).map(x => x)
    println(sugar == desugared)
  }
}

Por qué withFilter y no filter

withFilter es perezoso: no construye una colección intermedia. La condición se aplica únicamente cuando se ejecuta el map o flatMap siguiente, lo que ahorra memoria y trabajo.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    val result = for (n <- nums if n % 3 == 0) yield n * 100
    println(result)
  }
}

Varias guardas

Puede encadenar varias guardas. Se combinan como un AND lógico: un elemento debe cumplir todas las condiciones para conservarse.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 20
      if x % 2 == 0
      if x % 3 == 0
    } yield x
    println(result)
  }
}

Guardas con varios generadores

Las guardas pueden aparecer después de cualquier generador y filtrar ese nivel de iteración. Coloque la guarda justo después del generador cuyos valores comprueba.

object Main {
  def main(args: Array[String]): Unit = {
    val coprimeSums = for {
      x <- 1 to 3
      y <- 1 to 3
      if x != y
    } yield (x, y)
    println(coprimeSums)
  }
}

Combinar una guarda y una vinculación de valores

Puede mezclar libremente guardas (if) con vinculaciones de valores (=). El orden importa: una vinculación definida antes de una guarda puede usarse dentro de ella.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 6
      square = x * x
      if square > 10
    } yield square
    println(result)
  }
}

Guardas en colecciones de String

Las guardas funcionan con cualquier predicado, no solo con predicados numéricos. Aquí filtramos palabras por longitud.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("scala", "go", "java", "rust", "c")
    val longWords = for (w <- words if w.length >= 4) yield w.toUpperCase
    println(longWords)
  }
}

Filtrar Options

Para una Option, una guarda que no se cumple convierte el resultado en None. Esto hace que las for-comprehensions sean una forma clara de validar valores opcionales.

object Main {
  def main(args: Array[String]): Unit = {
    val ok  = for (x <- Some(8) if x > 5) yield x
    val bad = for (x <- Some(3) if x > 5) yield x
    println(ok)
    println(bad)
  }
}

La posición de la guarda cambia el significado

Una guarda solo puede ver los valores vinculados por encima de ella. Colocarla antes de un generador que necesita no compilará. Coloque siempre la guarda después del generador correspondiente.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 3
      y <- 1 to 3
      if x + y == 4
    } yield s"$x + $y = ${x + y}"
    result.foreach(println)
  }
}

Guardas frente a un filter final

Podría filtrar el resultado después de la comprensión, pero una guarda filtra durante la iteración. Con varios generadores, las guardas pueden podar ramas pronto y reducir el trabajo total.

object Main {
  def main(args: Array[String]): Unit = {
    val withGuard = for {
      x <- 1 to 100
      if x % 25 == 0
    } yield x
    println(withGuard)
  }
}

Flujos de validación legibles

Encadenar guardas se lee como una lista de comprobación de condiciones. Este es uno de los usos más idiomáticos de las for-comprehensions en código Scala real.

object Main {
  def main(args: Array[String]): Unit = {
    val valid = for {
      n <- List(4, 7, 12, 15, 20)
      if n > 5
      if n < 18
      if n % 2 == 0
    } yield n
    println(valid)
  }
}

Comprobación rápida

¿En qué método se desazucara una guarda (if) dentro de una for-comprehension?

Resumen

Ha aprendido sobre las guardas en las for-comprehensions:

if cond filtra elementos durante la iteración
Las guardas se desazucaran como withFilter (filtrado perezoso)
Varias guardas se combinan como un AND lógico
Una guarda solo puede ver los valores vinculados por encima de ella
Las guardas se combinan libremente con generadores y vinculaciones con =

Preguntas frecuentes

¿La lección «Filtrado con if» es gratis?

Sí — el texto completo de «Filtrado con if» 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 «Filtrado con if»?

Guardas en comprehensions 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 2 de 4.

¿Cuánto tiempo toma la lección «Filtrado con if»?

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