Scala for Backend Engineering & Functional Programming · Aula

Try, Success, Failure

Tratamento de exceções.

Aula 2 de 413 etapas

Try, Success, Failure é 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.

O que é Try?

Try[T] representa um cálculo que pode resultar em um valor ou lançar uma exceção. Ele tem dois subtipos:

Success[T] encapsula um resultado normal.
Failure encapsula um Throwable.

Ele transforma código que lança exceções em um valor que você pode compor.

Importando Try

Try está em scala.util. Você envolve qualquer expressão que possa lançar uma exceção em Try { ... }, e ele captura exceções não fatais para você.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try(10 / 2)
  val bad = Try(10 / 0)
  println(ok)
  println(bad)
}

Sucesso e falha

Um Try que termina normalmente é um Success contendo o valor; aquele que lança uma exceção se torna um Failure contendo a exceção.

import scala.util.{Try, Success, Failure}

@main def run(): Unit = {
  val result = Try("123".toInt)
  result match {
    case Success(n) => println(s"parsed: $n")
    case Failure(e) => println(s"failed: ${e.getMessage}")
  }
}

Correspondência de padrões para falhas

Quando o código envolvido lança uma exceção, você pode inspecionar a exceção dentro de Failure. Aqui, uma análise inválida é capturada de forma limpa.

import scala.util.{Try, Success, Failure}

@main def run(): Unit = {
  val result = Try("abc".toInt)
  result match {
    case Success(n) => println(s"got $n")
    case Failure(e) => println(s"error type: ${e.getClass.getSimpleName}")
  }
}

getOrElse com Try

getOrElse retorna o valor de sucesso ou um valor padrão quando o Try falha. Isso evita lançar exceções completamente.

import scala.util.Try

@main def run(): Unit = {
  val n = Try("oops".toInt).getOrElse(-1)
  println(n)
}

map com Try

map transforma um valor de Success. Se o original for um Failure ou se a função de transformação lançar uma exceção, o resultado continuará sendo um Failure.

import scala.util.Try

@main def run(): Unit = {
  val doubled = Try("21".toInt).map(_ * 2)
  val failed  = Try("x".toInt).map(_ * 2)
  println(doubled)
  println(failed)
}

recover: Tratando a exceção

recover permite transformar um Failure novamente em um Success, tratando exceções específicas com uma função parcial.

import scala.util.Try

@main def run(): Unit = {
  val safe = Try("x".toInt).recover {
    case _: NumberFormatException => 0
  }
  println(safe)
}

recoverWith

recoverWith funciona como recover, mas o manipulador retorna outro Try em vez de um valor simples. Use-o quando a própria recuperação também puder falhar.

import scala.util.Try

@main def run(): Unit = {
  val result = Try("x".toInt).recoverWith {
    case _: NumberFormatException => Try("42".toInt)
  }
  println(result)
}

toEither e toOption

Try pode ser convertido facilmente em outros tipos de erro:

toOption: Success se torna Some, e Failure se torna None.
toEither: Success se torna Right, e Failure se torna Left(throwable).

import scala.util.Try

@main def run(): Unit = {
  println(Try("5".toInt).toOption)
  println(Try("x".toInt).toOption)
  println(Try("5".toInt).toEither.isRight)
}

Encadeando com flatMap

flatMap encadeia cálculos que retornam um Try. Se qualquer etapa falhar, toda a cadeia será interrompida e resultará nesse Failure.

import scala.util.Try

object Main {
  def half(n: Int): Try[Int] = Try(if (n % 2 == 0) n / 2 else throw new RuntimeException("odd"))

  def main(args: Array[String]): Unit = {
    println(Try("8".toInt).flatMap(half))
    println(Try("7".toInt).flatMap(half))
  }
}

Try versus try/catch

Try transforma exceções em valores, permitindo usar map, flatMap e combinar resultados sem blocos try/catch aninhados. Ele captura apenas exceções não fatais; erros graves, como OutOfMemoryError, continuam se propagando.

Verificação rápida

Teste seus conhecimentos sobre Try.

Responda na aula interativa

Recapitulação

Você aprendeu a tratar exceções com Try:

Try { ... } captura exceções não fatais como Failure e resultados normais como Success.
Transforme com map/flatMap; recupere-se com recover/recoverWith.
Forneça valores padrão com getOrElse.
Converta com toOption e toEither.

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 “Try, Success, Failure” é grátis?

Sim — o texto completo de “Try, Success, Failure” é 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 “Try, Success, Failure”?

Tratamento de exceçõ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 2 de 4.

Quanto tempo leva a aula “Try, Success, Failure”?

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