Scala for Backend Engineering & Functional Programming · Lekcja

Konwersja między typami

Option, Either, Try

Konwersja między typami to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 4 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.

Trzy modele błędów

Scala oferuje trzy uzupełniające się typy do reprezentowania braku wartości i niepowodzenia:

Option — obecność albo brak wartości (bez informacji o przyczynie).
Either — sukces albo typowany błąd.
Try — sukces albo zgłoszony wyjątek.

Znajomość konwersji między nimi pozwala dostosować jeden interfejs API do drugiego.

Konwersja Option na Either

toRight konwertuje Option na Either, dostarczając błąd Left w przypadku None. toLeft wykonuje odwrotne mapowanie.

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

Either na Option

toOption usuwa informację o błędzie: Right(x) staje się Some(x), a Left(_) staje się None. Należy użyć tego rozwiązania, gdy przyczyna niepowodzenia nie ma już znaczenia.

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

Try na Option

Try.toOption zamienia Success na Some, a Failure na None, ignorując wyjątek.

import scala.util.Try

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

Try na Either

Try.toEither tworzy Either[Throwable, T]: Success staje się Right, a Failure staje się Left(throwable). Dzięki temu wyjątek zostaje zachowany jako typowana lewa wartość.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

Either na Try

Nie ma bezpośredniej wbudowanej konwersji z Either na Try dla zwykłego błędu, ale można ją utworzyć samodzielnie: opakować Right w Success, a Left w Failure zawierający wyjątek.

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

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

Option na Try

Konwertuj Option na Try, wybierając wyjątek dla pustego przypadku. Jest to przydatne, gdy interfejs API oczekuje wartości typu Try.

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

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

Normalizowanie potoku

Mieszanie typów powoduje problemy. Często stosuje się podejście polegające na wczesnej konwersji wszystkiego do Either z jednolitym typem błędu, a następnie swobodnym składaniu operacji.

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

getOrElse dla różnych typów

Wszystkie trzy typy obsługują getOrElse, które wyodrębnia wartość albo dostarcza wartość domyślną. Często jest to ostatni krok kończący obsługę błędów.

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

Wybór właściwego typu

Wskazówki:

Użyj typu Option, gdy brak wartości nie wymaga wyjaśnienia.
Użyj typu Either, gdy chcesz użyć specyficznej dla domeny wartości błędu.
Użyj typu Try na granicach z kodem Java lub bibliotek, który zgłasza wyjątki.

Przykład od początku do końca

Odczytywanie kodu zgłaszającego wyjątki za pomocą Try, konwertowanie go na Either dla błędów domenowych, a następnie na Option dla wywołującego, którego interesuje tylko obecność wartości.

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat konwersji.

Podsumowanie

Nauczyłeś się konwertować między typami Option, Either i Try:

Option.toRight → Either; Either.toOption → Option.
Try.toOption i Try.toEither łączą wyjątki z wartościami.
Wcześnie normalizuj potok do jednego typu błędu.
Wybieraj typ odpowiadający ilości szczegółów o błędzie, których potrzebujesz.

Często zadawane pytania

Czy lekcja „Konwersja między typami” jest bezpłatna?

Tak — pełny tekst „Konwersja między typami” 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 „Konwersja między typami”?

Option, Either, Try Ć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 4 z 4.

Ile czasu zajmuje lekcja „Konwersja między typami”?

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

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