0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Either do obsługi błędów

Left i Right

Either do obsługi błędów to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 z 4. 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 4 lekcji w sumie.

Dlaczego Either?

Either reprezentuje wartość, która może przyjmować jedną z dwóch możliwości. Jest idiomatycznym sposobem modelowania obliczeń, które mogą zakończyć się niepowodzeniem z informacją o przyczynie błędu.

  • Left umownie przechowuje błąd.
  • Right umownie przechowuje wartość oznaczającą sukces.

W przeciwieństwie do Option, które informuje jedynie, że czegoś brakuje, Either wskazuje, co poszło nie tak.

Typ Either

Either[A, B] jest zapieczętowaną cechą z dwoma podtypami: Left[A] i Right[B].

Pomocne skojarzenie: Right is right (czyli „prawy ma rację”), a Left oznacza błąd. Dzięki tej konwencji map i flatMap automatycznie działają po stronie sukcesu.

val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)

Zwracanie Either z funkcji

Funkcja, która może zakończyć się niepowodzeniem, zwraca Either zamiast zgłaszać wyjątek. Kod wywołujący może wtedy jawnie obsłużyć oba wyniki.

object Main {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 => Right(n)
      case Some(_)          => Left("age cannot be negative")
      case None             => Left("not a number")
    }

  def main(args: Array[String]): Unit = {
    println(parseAge("30"))
    println(parseAge("-5"))
    println(parseAge("x"))
  }
}

Dopasowanie wzorców dla Either

Najbardziej bezpośrednim sposobem użycia Either jest dopasowanie wzorców. Obsługują Państwo osobno przypadki Left i Right.

@main def run(): Unit = {
  val result: Either[String, Int] = Right(10)
  val msg = result match {
    case Right(value) => s"Got value: $value"
    case Left(error)  => s"Failed: $error"
  }
  println(msg)
}

fold: Połączenie obu stron

fold przyjmuje dwie funkcje: jedną dla Left i jedną dla Right, a następnie zwraca pojedynczy wynik wspólnego typu.

Jest to zwięzła alternatywa dla dopasowania wzorców, gdy chcą Państwo otrzymać wartość.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(7)
  val label = r.fold(
    err => s"error: $err",
    num => s"double is ${num * 2}"
  )
  println(label)
}

map działa na Right

map przekształca wartość Right, pozostawiając Left bez zmian. Jest to prawostronne działanie Either w Scali (od wersji 2.12).

@main def run(): Unit = {
  val ok: Either[String, Int]  = Right(5)
  val no: Either[String, Int]  = Left("missing")
  println(ok.map(_ + 1))
  println(no.map(_ + 1))
}

getOrElse i wartości domyślne

getOrElse wyodrębnia wartość Right albo zwraca wartość zastępczą, gdy Either ma postać Left.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(99)
  val no: Either[String, Int] = Left("oops")
  println(ok.getOrElse(0))
  println(no.getOrElse(0))
}

swap: Zamiana stron

swap zamienia miejscami Left i Right. Jest to przydatne, gdy chcą Państwo operować na stronie błędu za pomocą metod działających prawostronnie.

@main def run(): Unit = {
  val err: Either[String, Int] = Left("bad input")
  val swapped = err.swap.map(_.toUpperCase)
  println(swapped)
}

isLeft i isRight

Szybkie sprawdzenia boolowskie pozwalają rozgałęziać kod bez pełnego dopasowania wzorców.

  • isRight zwraca true dla sukcesu.
  • isLeft zwraca true dla błędu.
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: Odrzucanie błędu

Gdy nie interesuje już Państwa dlaczego coś się nie powiodło, toOption konwertuje Either na Option: Right(x) staje się Some(x), a Left(_) staje się None.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(3)
  val no: Either[String, Int] = Left("err")
  println(ok.toOption)
  println(no.toOption)
}

Przykład walidacji

Połączmy wszystko: sprawdźmy nazwę użytkownika, zwracając typowany błąd w razie niepowodzenia.

object Main {
  def validate(name: String): Either[String, String] =
    if (name.isEmpty) Left("empty name")
    else if (name.length > 10) Left("name too long")
    else Right(name)

  def main(args: Array[String]): Unit = {
    println(validate("alice"))
    println(validate(""))
    println(validate("verylongusername"))
  }
}

Szybkie sprawdzenie

Sprawdźmy, czy rozumieją Państwo konwencje związane z Either.

Podsumowanie

Opanował(a) Pan/Pani modelowanie błędów za pomocą Either:

  • Right = sukces, Left = błąd (działanie prawostronne).
  • Wartości można przetwarzać za pomocą dopasowania wzorców lub fold.
  • Sukces można przekształcać za pomocą map, a wartości domyślne zapewniać przez getOrElse.
  • Strony można zamieniać za pomocą swap, a konwertować przez toOption.

W następnej części zajmą się Państwo wyjątkami za pomocą Try.

Często zadawane pytania

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

Tak — pełny tekst „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 4 lekcji w sumie.

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

Left i Right Ć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 1 z 4.

Ile czasu zajmuje lekcja „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

  1. Either do obsługi błędów
  2. Try, Success, Failure
  3. Komponowanie Either
  4. Konwersja między typami
← Powrót do Scala for Backend Engineering & Functional Programming