PricingLoginStart free
Scala for Backend Engineering & Functional Programming · Aula

Option em for-comprehensions

Encadeie opções.

Aula 4 de 413 etapas

Option em for-comprehensions é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 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.

Encadeando Options de forma clara

Encadear várias chamadas de flatMap e map pode dificultar a leitura. A compreensão for do Scala oferece uma sintaxe mais clara para fazer a mesma coisa.

Ela é um recurso sintático que o compilador reescreve em chamadas de flatMap e map.

Compreensão for básica

Dentro de for { ... } yield ..., cada x <- option extrai o valor quando ele está presente. O yield constrói o resultado final.

Se todas as Options forem uma Some, você obterá uma Some com o resultado.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Interrupção em None

Se algum gerador for None, toda a compreensão produzirá None. As etapas restantes serão ignoradas.

Essa é a mesma interrupção antecipada fornecida por flatMap, mas com uma leitura mais fácil.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = None
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Como ela é simplificada

O compilador reescreve uma compreensão for em flatMap e map. Estes dois trechos são equivalentes.

Entender isso ajuda você a prever o tipo do resultado.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val viaFor = for { x <- a; y <- b } yield x + y
    val viaFlatMap = a.flatMap(x => b.map(y => x + y))
    println(viaFor)
    println(viaFlatMap)
  }
}

Usando valores anteriores

Os geradores posteriores podem fazer referência a valores vinculados anteriormente. Isso permite que cada etapa dependa da anterior.

object Main {
  def main(args: Array[String]): Unit = {
    val base: Option[Int] = Some(10)
    val result = for {
      x <- base
      y <- Some(x * 2)
    } yield x + y
    println(result)
  }
}

Vinculações intermediárias

Você pode introduzir valores simples dentro da compreensão usando = (sem seta). Isso é útil para cálculos intermediários.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(6)
    val result = for {
      x <- a
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

Guardas com if

Uma compreensão pode incluir um filtro if. Se a condição falhar, o resultado se tornará None.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(8)
    val even = for {
      x <- a
      if x % 2 == 0
    } yield x
    println(even)
    val b: Option[Int] = Some(7)
    println(for { x <- b if x % 2 == 0 } yield x)
  }
}

Combinando consultas

Um uso comum é consultar várias chaves e combiná-las somente se todas estiverem presentes.

object Main {
  val data = Map("a" -> 1, "b" -> 2)
  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- data.get("a")
      y <- data.get("b")
    } yield x + y
    println(combined)
    val missing = for {
      x <- data.get("a")
      z <- data.get("c")
    } yield x + z
    println(missing)
  }
}

Por que usar compreensões for?

Elas oferecem:

  • Uma sequência legível de Options dependentes
  • Interrupção automática em None
  • O mesmo poder de flatMap/map, mas de forma mais linear
  • Filtragem com if e vinculações intermediárias com =

Chegando a um valor

A compreensão produz uma Option; portanto, finalize com getOrElse ou fold para obter um valor simples.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val total = (for { x <- a; y <- b } yield x + y).getOrElse(0)
    println(total)
  }
}

Reunindo tudo

Um fluxo completo: analise duas entradas, verifique uma condição, combine os valores e forneça um padrão.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("10")
      y <- parse("5")
      if y != 0
    } yield x / y
    println(result.getOrElse(-1))
  }
}

Verificação rápida

Teste sua compreensão sobre compreensões for usando Option.

Responda na aula interativa

Recapitulação

Você aprendeu a encadear Options com compreensões for:

  • for { x <- a; y <- b } yield ... organiza Options de forma legível
  • Ela é simplificada para flatMap/map
  • Qualquer None interrompe todo o resultado, tornando-o None
  • Os geradores posteriores podem usar valores anteriores; = adiciona vinculações; if filtra
  • Finalize com getOrElse ou fold para obter um valor simples
Grátis para começar

Aprenda Scala com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
39
Aulas
143
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Option em for-comprehensions” é grátis?

Sim — o texto completo de “Option em for-comprehensions” é 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 “Option em for-comprehensions”?

Encadeie opções. 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 4 de 4.

Quanto tempo leva a aula “Option em for-comprehensions”?

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

  1. Evitando null
  2. map e flatMap em Option
  3. getOrElse e fold
  4. Option em for-comprehensions
← Voltar para Scala for Backend Engineering & Functional Programming