Scala for Backend Engineering & Functional Programming · Aula

getOrElse e fold

Extraia valores.

Aula 3 de 413 etapas

getOrElse e fold é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 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.

Obtendo um valor

Em algum momento, você precisará extrair um valor simples de um Option, fornecendo algo apropriado quando ele for None.

Scala oferece extratores seguros, como getOrElse e fold, para isso.

Usando getOrElse

getOrElse retorna o valor dentro de um Some ou um valor padrão que você fornece quando ele é None.

Ele sempre fornece um valor simples, nunca um Option.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(5)
    val b: Option[Int] = None
    println(a.getOrElse(0))
    println(b.getOrElse(0))
  }
}

O padrão é avaliado de forma tardia

O valor padrão em getOrElse só é avaliado quando o Option é None. Assim, um padrão caro não tem custo quando há um valor presente.

object Main {
  def expensiveDefault(): Int = { println("computing default"); 99 }
  def main(args: Array[String]): Unit = {
    val present: Option[Int] = Some(7)
    println(present.getOrElse(expensiveDefault()))
  }
}

Evitando get

Option tem um método get, mas ele lança uma exceção quando recebe None. Isso vai contra o propósito de usar Option.

Prefira getOrElse, fold ou correspondência de padrões.

orElse para opções alternativas

orElse é diferente: ele retorna a primeira opção se ela for uma Some; caso contrário, retorna uma Option alternativa.

Use-o para tentar alternativas que também podem estar vazias.

object Main {
  def main(args: Array[String]): Unit = {
    val primary: Option[Int] = None
    val backup: Option[Int] = Some(42)
    println(primary.orElse(backup))
  }
}

Apresentando fold

fold trata os dois casos em uma única chamada. Primeiro, informe um valor padrão para None e, depois, uma função para o valor Some.

Ele retorna um único resultado, transformando o valor quando ele está presente.

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(10)
    val result = n.fold(0)(x => x * 2)
    println(result)
  }
}

fold com None

Quando a opção é None, fold retorna o valor padrão informado primeiro e ignora a função de transformação.

object Main {
  def main(args: Array[String]): Unit = {
    val empty: Option[Int] = None
    val result = empty.fold(-1)(x => x * 2)
    println(result)
  }
}

fold para um tipo diferente

Os dois ramos de fold devem retornar o mesmo tipo, mas esse tipo pode ser diferente do tipo do valor de Option.

Aqui, transformamos um Option[Int] em uma String.

object Main {
  def describe(o: Option[Int]): String =
    o.fold("missing")(x => s"value $x")
  def main(args: Array[String]): Unit = {
    println(describe(Some(8)))
    println(describe(None))
  }
}

Escolhendo entre eles

Guia rápido:

getOrElse: fornece um valor padrão do mesmo tipo
orElse: fornece uma Option alternativa
fold: transforma o valor e fornece um padrão em uma única etapa
correspondência de padrões: quando cada caso precisa de mais lógica

Combinando com map

Um padrão comum é usar map primeiro para transformar e, depois, getOrElse para chegar a um valor simples.

object Main {
  def main(args: Array[String]): Unit = {
    val name: Option[String] = Some("ada")
    val display = name.map(_.toUpperCase).getOrElse("ANON")
    println(display)
  }
}

Reunindo tudo

Procure um valor de configuração, forneça uma Option alternativa e, depois, chegue a um valor padrão com getOrElse.

object Main {
  val env = Map("timeout" -> "30")
  def main(args: Array[String]): Unit = {
    val timeout = env.get("timeout")
      .flatMap(_.toIntOption)
      .getOrElse(60)
    println(timeout)
    val retries = env.get("retries").fold(3)(_.toInt)
    println(retries)
  }
}

Verificação rápida

Teste sua compreensão sobre como extrair valores de Option.

Responda na aula interativa

Recapitulação

Você aprendeu a extrair valores de Option com segurança:

getOrElse(default) retorna o valor ou um padrão (avaliado de forma tardia)
orElse(fallback) retorna o primeiro Some ou uma Option alternativa
fold(default)(f) transforma um Some e fornece um padrão para None em uma única etapa
Evite get, que lança uma exceção para None

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átis Ver o curso completo

Perguntas Frequentes

A aula “getOrElse e fold” é grátis?

Sim — o texto completo de “getOrElse e fold” é 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 “getOrElse e fold”?

Extraia valores. 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 3 de 4.

Quanto tempo leva a aula “getOrElse e fold”?

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