Scala for Backend Engineering & Functional Programming · Lección

Option, Try y Either para errores

Implemente una gestión sólida de errores utilizando `Option` para la ausencia de valores, `Try` para las excepciones y `Either` para distinguir entre rutas de fallo y éxito.

Option, Try y Either para errores es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 3. 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 3 lecciones en total.

Manejo adecuado de errores

En programación, no todo sale siempre según lo previsto. Es posible que algunos archivos no existan, que fallen las solicitudes de red o que los cálculos produzcan resultados no válidos.

¿Cómo se escribe código sólido capaz de gestionar estas situaciones correctamente?
Scala proporciona herramientas potentes para gestionar errores y valores ausentes sin recurrir a `null` ni lanzar excepciones por todas partes.

El problema de null

Muchos lenguajes utilizan null para representar la ausencia de un valor. Sin embargo, null es una fuente habitual de errores, como la temida NullPointerException.

Scala desaconseja usar null. En su lugar, ofrece tipos que indican explícitamente si un valor puede faltar, lo que hace que el código sea más seguro y fácil de entender.

Introducción a Scala Option

Option[A] es un contenedor que puede contener un valor de tipo A (representado por Some[A]) o ningún valor (representado por None).

Le obliga a considerar el caso en que un valor pueda estar ausente.
Esto evita NullPointerExceptions inesperadas y hace que el código sea más explícito.

Option en acción: Some y None

Veamos cómo funciona Option. Definiremos una función que puede devolver un nombre o no, según un identificador.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val user1 = findUser(1) // Some("Alice")
    val user2 = findUser(2) // None

    println(s"User 1: $user1")
    println(s"User 2: $user2")
  }
}

Trabajo con Option: map y getOrElse

Puede transformar el valor dentro de un Option mediante map o proporcionar un valor predeterminado si es None mediante getOrElse.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val userGreeting = findUser(1).map(name => s"Hello, $name!")
    val defaultGreeting = findUser(2).map(name => s"Hello, $name!").getOrElse("Hello, Guest!")

    println(s"User greeting: $userGreeting")
    println(s"Default greeting: $defaultGreeting")
  }
}

Introducción a Scala Try

Mientras que Option gestiona los valores ausentes, Try[A] está diseñado para gestionar cálculos que podrían lanzar una excepción.

Un Try puede ser un Success[A] (si el cálculo finaliza normalmente) o un Failure[Throwable] (si se produce una excepción).
Encapsula las excepciones, lo que permite gestionarlas de forma funcional.

Try en acción: Success y Failure

Definiremos una función que podría lanzar una excepción (por ejemplo, una división entre cero) y envolveremos su ejecución en un Try.

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

object Main {
  def divide(a: Int, b: Int): Try[Int] = Try {
    a / b
  }

  def main(args: Array[String]): Unit = {
    val result1 = divide(10, 2) // Success(5)
    val result2 = divide(10, 0) // Failure(java.lang.ArithmeticException: / by zero)

    println(s"Result 1: $result1")
    println(s"Result 2: $result2")
  }
}

Trabajo con Try: recover y fold

Try ofrece métodos como recover para gestionar excepciones específicas o fold para procesar de forma clara tanto los casos de éxito como los de error.

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

object Main {
  def parseNumber(s: String): Try[Int] = Try(s.toInt)

  def main(args: Array[String]): Unit = {
    val num1 = parseNumber("123").getOrElse(0)
    val num2 = parseNumber("abc").getOrElse(0)

    val message = parseNumber("456").fold(
      ex => s"Failed to parse: ${ex.getMessage}",
      num => s"Parsed number: $num"
    )

    println(s"Parsed num1: $num1")
    println(s"Parsed num2: $num2")
    println(s"Message: $message")
  }
}

Introducción a Scala Either

Either[L, R] es un tipo que representa uno de dos valores posibles. Por convención:

Left[L] representa un error (o el tipo de error L).
Right[R] representa un resultado correcto (o el tipo de resultado R).

A diferencia de Try, Either permite especificar un tipo significativo para el error, en lugar de limitarse a Throwable.

Either en acción: Left y Right

Esta es una función que valida un correo electrónico. Devuelve un mensaje de error de tipo String (Left) o el correo electrónico validado (Right).

object Main {
  def validateEmail(email: String): Either[String, String] = {
    if (email.contains("@") && email.contains(".")) Right(email)
    else Left("Invalid email format")
  }

  def main(args: Array[String]): Unit = {
    val email1 = validateEmail("test@example.com") // Right("test@example.com")
    val email2 = validateEmail("invalid-email")   // Left("Invalid email format")

    println(s"Email 1: $email1")
    println(s"Email 2: $email2")
  }
}

Comprobación rápida: manejo de errores

Está escribiendo una función que lee un valor de configuración de un mapa. Si la clave existe, quiere convertir su valor de cadena en un entero. Si falta la clave o la conversión falla, quiere devolver el valor predeterminado 0.

¿Qué combinación de tipos y métodos de Scala sería la más adecuada para esta tarea?

Resumen: Option, Try y Either

Hemos explorado tres tipos potentes de Scala para gestionar errores de forma sólida:

Option[A]: para gestionar la ausencia de un valor (Some[A] o None).
Try[A]: para encapsular cálculos que podrían lanzar excepciones (Success[A] o Failure[Throwable]).
Either[L, R]: para representar dos resultados distintos, normalmente un tipo de error L y un tipo de éxito R (Left[L] o Right[R]).

El uso de estos tipos hace que su código Scala sea más seguro, explícito y funcional.

Preguntas frecuentes

¿La lección «Option, Try y Either para errores» es gratis?

Sí — el texto completo de «Option, Try y Either para errores» 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 3 lecciones en total.

¿Qué aprenderé en «Option, Try y Either para errores»?

Implemente una gestión sólida de errores utilizando `Option` para la ausencia de valores, `Try` para las excepciones y `Either` para distinguir entre rutas de fallo y éxito. 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 3 de 3.

¿Cuánto tiempo toma la lección «Option, Try y Either para errores»?

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

Profundización en colecciones inmutables
Operaciones funcionales sobre colecciones
Option, Try y Either para errores

← Volver a Scala for Backend Engineering & Functional Programming