Scala for Backend Engineering & Functional Programming · Lección

Try, Success, Failure

Gestión de excepciones

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

¿Qué es Try?

Try[T] representa un cálculo que puede producir un valor o lanzar una excepción. Tiene dos subtipos:

Success[T] envuelve un resultado normal.
Failure envuelve un Throwable.

Convierte el código que lanza excepciones en un valor que puede componerse.

Importar Try

Try se encuentra en scala.util. Envuelva cualquier expresión que pueda lanzar una excepción dentro de Try { ... } y capturará las excepciones no fatales por usted.

import scala.util.Try

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

Success y Failure

Un Try que termina normalmente es un Success que contiene el valor; uno que lanza una excepción se convierte en un Failure que contiene la excepción.

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

Coincidencia de patrones con errores

Cuando el código envuelto lanza una excepción, puede inspeccionarla dentro de Failure. Aquí, un análisis incorrecto se captura limpiamente.

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 con Try

getOrElse devuelve el valor satisfactorio o un valor predeterminado cuando Try ha fallado. Así se evita lanzar excepciones por completo.

import scala.util.Try

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

map sobre Try

map transforma un valor de Success. Si el valor original es un Failure o la función de transformación lanza una excepción, el resultado sigue siendo un 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: gestionar la excepción

recover le permite convertir un Failure de nuevo en un Success gestionando excepciones específicas con una función parcial.

import scala.util.Try

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

recoverWith

recoverWith es similar a recover, pero el controlador devuelve otro Try en lugar de un valor simple. Úselo cuando la propia recuperación pueda fallar.

import scala.util.Try

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

toEither y toOption

Try se convierte fácilmente en otros tipos de error:

toOption: Success se convierte en Some y Failure en None.
toEither: Success se convierte en Right y Failure en 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)
}

Encadenar con flatMap

flatMap secuencia cálculos que devuelven un Try. Si algún paso falla, toda la cadena termina inmediatamente en ese 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 frente a try/catch

Try convierte las excepciones en valores, por lo que puede usar map, flatMap y combinar resultados sin bloques try/catch anidados. Solo captura excepciones no fatales; los errores graves, como OutOfMemoryError, siguen propagándose.

Comprobación rápida

Compruebe sus conocimientos sobre Try.

Resumen

Ha aprendido a gestionar excepciones con Try:

Try { ... } captura las excepciones no fatales como Failure y los resultados normales como Success.
Transforme valores con map/flatMap y recupérese con recover/recoverWith.
Proporcione valores predeterminados con getOrElse.
Convierta con toOption y toEither.

Preguntas frecuentes

¿La lección «Try, Success, Failure» es gratis?

Sí — el texto completo de «Try, Success, Failure» 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 «Try, Success, Failure»?

Gestión de excepciones 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 «Try, Success, Failure»?

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