Scala for Backend Engineering & Functional Programming · Lekcja

Option, Try i Either do obsługi błędów

Zaimplementuj solidną obsługę błędów, używając `Option` w przypadku braku wartości, `Try` dla wyjątków oraz `Either` dla rozróżnienia ścieżek niepowodzenia i powodzenia.

Option, Try i Either do obsługi błędów to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Eleganckie obsługiwanie błędów

W programowaniu nie wszystko zawsze przebiega zgodnie z planem. Pliki mogą nie istnieć, żądania sieciowe mogą się nie powieść, a obliczenia mogą prowadzić do nieprawidłowych wyników.

Jak pisać niezawodny kod, który elegancko radzi sobie z takimi sytuacjami?
Scala udostępnia zaawansowane narzędzia do zarządzania błędami i brakującymi wartościami bez używania `null` ani rzucania wyjątków w każdym miejscu.

Problem z null

Wiele języków używa null do oznaczania braku wartości. Jednak null często powoduje błędy, takie jak budzący grozę NullPointerException.

Scala zniechęca do używania null. Zamiast tego oferuje typy, które jawnie informują, czy wartości może brakować, dzięki czemu kod jest bezpieczniejszy i łatwiejszy do zrozumienia.

Wprowadzenie do Scala Option

Option[A] to kontener, który może zawierać wartość typu A (reprezentowaną przez Some[A]) albo nie zawierać żadnej wartości (reprezentowaną przez None).

Wymusza uwzględnienie sytuacji, w której wartości może brakować.
Zapobiega to nieoczekiwanym wyjątkom NullPointerException i sprawia, że kod jest bardziej jednoznaczny.

Option w praktyce: Some i None

Zobaczmy, jak działa Option. Zdefiniujemy funkcję, która w zależności od identyfikatora może zwrócić nazwę albo nie zwrócić żadnej wartości.

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

Praca z Option: map i getOrElse

Wartość wewnątrz Option można przekształcić za pomocą map albo podać wartość domyślną, gdy wynikiem jest None, używając 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")
  }
}

Wprowadzenie do Scala Try

Podczas gdy Option obsługuje brakujące wartości, Try[A] służy do obsługi obliczeń, które mogą zgłosić wyjątek.

Try może mieć wartość Success[A] (jeśli obliczenia zakończą się normalnie) albo Failure[Throwable] (jeśli wystąpi wyjątek).
Hermetyzuje wyjątki, umożliwiając ich funkcyjną obsługę.

Try w praktyce: Success i Failure

Zdefiniujmy funkcję, która może zgłosić wyjątek (np. przy dzieleniu przez zero), i opakujmy jej wykonanie w 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")
  }
}

Praca z Try: recover i fold

Try udostępnia metody takie jak recover do obsługi określonych wyjątków oraz fold do przejrzystego przetwarzania zarówno przypadków powodzenia, jak i niepowodzenia.

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

Wprowadzenie do Scala Either

Either[L, R] to typ reprezentujący jedną z dwóch możliwych wartości. Zgodnie z konwencją:

Left[L] reprezentuje niepowodzenie (lub typ błędu L).
Right[R] reprezentuje powodzenie (lub typ wyniku R).

W przeciwieństwie do Try, Either pozwala określić znaczący typ błędu, a nie tylko Throwable.

Either w praktyce: Left i Right

Oto funkcja, która sprawdza poprawność adresu e-mail. Zwraca albo komunikat o błędzie typu String (Left), albo zweryfikowany adres e-mail (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")
  }
}

Szybkie sprawdzenie: obsługa błędów

Piszesz funkcję, która odczytuje wartość konfiguracji z mapy. Jeśli klucz istnieje, chcesz przekonwertować jego wartość tekstową na liczbę całkowitą. Jeśli klucza brakuje albo konwersja się nie powiedzie, chcesz zwrócić domyślną wartość 0.

Jaka kombinacja typów i metod Scali będzie najbardziej odpowiednia do tego zadania?

Podsumowanie: Option, Try, Either

Omówiliśmy trzy zaawansowane typy Scali służące do niezawodnej obsługi błędów:

Option[A]: do obsługi braku wartości (Some[A] lub None).
Try[A]: do hermetyzowania obliczeń, które mogą zgłosić wyjątki (Success[A] lub Failure[Throwable]).
Either[L, R]: do reprezentowania dwóch odrębnych wyników, zazwyczaj typu błędu L i typu powodzenia R (Left[L] lub Right[R]).

Używanie tych typów sprawia, że kod Scala jest bezpieczniejszy, bardziej jednoznaczny i bardziej funkcjonalny!

Często zadawane pytania

Czy lekcja „Option, Try i Either do obsługi błędów” jest bezpłatna?

Tak — pełny tekst „Option, Try i Either do obsługi błędów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Co nauczysz się w „Option, Try i Either do obsługi błędów”?

Zaimplementuj solidną obsługę błędów, używając `Option` w przypadku braku wartości, `Try` dla wyjątków oraz `Either` dla rozróżnienia ścieżek niepowodzenia i powodzenia. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Option, Try i Either do obsługi błędów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Dogłębne poznanie niemutowalnych kolekcji
Operacje funkcyjne na kolekcjach
Option, Try i Either do obsługi błędów

← Powrót do Scala for Backend Engineering & Functional Programming