Scala for Backend Engineering & Functional Programming · Aula

Filtrando com if

Guardas em comprehensions.

Filtrando com if é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Guardas em compreensões for

Dentro de uma compreensão for, você pode adicionar uma condição if chamada guarda. Ela mantém apenas os elementos que satisfazem a condição, assim como filter.

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

Guardas são simplificadas para withFilter

Uma guarda if cond é reescrita em uma chamada de withFilter (uma variante tardia de filter).

for (x <- xs if p(x)) yield x
torna-se 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 que withFilter, e não filter

withFilter é tardio: ele não cria uma coleção intermediária. A condição só é aplicada quando o map ou flatMap seguinte é executado, economizando memória e trabalho.

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

Várias guardas

Você pode encadear várias guardas. Elas se combinam como um E lógico: um elemento precisa satisfazer todas as condições para permanecer.

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 com vários geradores

As guardas podem aparecer depois de qualquer gerador e filtrar esse nível de iteração. Coloque a guarda logo depois do gerador cujos valores ela testa.

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

Combinando uma guarda e uma vinculação de valor

Você pode misturar livremente guardas (if) com vinculações de valores (=). A ordem importa: uma vinculação definida antes de uma guarda pode ser usada dentro dela.

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 em coleções de String

As guardas funcionam com qualquer predicado, não apenas com predicados numéricos. Aqui, filtramos palavras por comprimento.

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

Filtrando Options

Para uma Option, uma guarda que falha transforma o resultado em None. Isso faz das compreensões for uma forma clara de validar valores opcionais.

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

A posição da guarda altera o significado

Uma guarda só enxerga os valores vinculados acima dela. Colocá-la antes de um gerador de que ela precisa não será compilado. Sempre coloque uma guarda depois do gerador relevante.

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 versus um filtro final

Você poderia filtrar o resultado depois da compreensão, mas uma guarda filtra durante a iteração. Com vários geradores, as guardas podem eliminar ramos antecipadamente, realizando menos trabalho no total.

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

Fluxos de validação legíveis

Empilhar guardas é como ler uma lista de verificação de condições. Esse é um dos usos mais idiomáticos das compreensões for em 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)
  }
}

Verificação rápida

Em qual método uma guarda (if) em uma compreensão for é simplificada?

Recapitulação

Você aprendeu sobre guardas em compreensões for:

if cond filtra elementos durante a iteração
As guardas são simplificadas para withFilter (filtragem tardia)
Várias guardas se combinam como um E lógico
Uma guarda só enxerga os valores vinculados acima dela
As guardas podem ser combinadas livremente com geradores e vinculações com =

Perguntas Frequentes

A aula “Filtrando com if” é grátis?

Sim — o texto completo de “Filtrando com if” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Filtrando com if”?

Guardas em comprehensions. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Filtrando com if”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming