Scala for Backend Engineering & Functional Programming · Lekcja

getOrElse i fold

Wyodrębnianie wartości

Lekcja 3 z 413 kroki

getOrElse i fold to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 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.

Pobieranie wartości

W pewnym momencie trzeba wyodrębnić zwykłą wartość z Option, podając rozsądną wartość w sytuacji, gdy jest to None.

Scala udostępnia do tego bezpieczne metody wyodrębniania, takie jak getOrElse i fold.

Używanie getOrElse

getOrElse zwraca wartość znajdującą się w Some albo podaną wartość domyślną, gdy mamy None.

Zawsze zwraca zwykłą wartość, nigdy Option.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(5)
    val b: Option[Int] = None
    println(a.getOrElse(0))
    println(b.getOrElse(0))
  }
}

Wartość domyślna jest obliczana leniwie

Wartość domyślna w getOrElse jest obliczana tylko wtedy, gdy Option ma wartość None. Oznacza to, że kosztowna wartość domyślna nic nie kosztuje, gdy wartość jest obecna.

object Main {
  def expensiveDefault(): Int = { println("computing default"); 99 }
  def main(args: Array[String]): Unit = {
    val present: Option[Int] = Some(7)
    println(present.getOrElse(expensiveDefault()))
  }
}

Unikanie get

Option ma metodę get, ale dla None zgłasza wyjątek. Niweczy to sens używania Option.

Zamiast niej proszę używać getOrElse, fold lub dopasowania wzorca.

orElse dla opcji zastępczych

orElse działa inaczej: zwraca pierwszą opcję, jeśli ma ona wartość Some, a w przeciwnym razie zwraca zastępczą opcję Option.

Proszę używać tej metody do wypróbowywania alternatyw, które same mogą być puste.

object Main {
  def main(args: Array[String]): Unit = {
    val primary: Option[Int] = None
    val backup: Option[Int] = Some(42)
    println(primary.orElse(backup))
  }
}

Wprowadzenie do fold

fold obsługuje oba przypadki w jednym wywołaniu. Najpierw podaje się wartość domyślną dla None, a następnie funkcję dla wartości Some.

Metoda zwraca pojedynczy wynik, przekształcając wartość, jeśli jest obecna.

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(10)
    val result = n.fold(0)(x => x * 2)
    println(result)
  }
}

fold dla None

Gdy Option ma wartość None, fold zwraca najpierw podaną wartość domyślną i ignoruje funkcję przekształcającą.

object Main {
  def main(args: Array[String]): Unit = {
    val empty: Option[Int] = None
    val result = empty.fold(-1)(x => x * 2)
    println(result)
  }
}

fold do innego typu

Obie gałęzie fold muszą zwracać ten sam typ, ale typ ten może różnić się od typu wartości przechowywanej w Option.

W tym przypadku przekształcamy Option[Int] w String.

object Main {
  def describe(o: Option[Int]): String =
    o.fold("missing")(x => s"value $x")
  def main(args: Array[String]): Unit = {
    println(describe(Some(8)))
    println(describe(None))
  }
}

Wybór odpowiedniej metody

Krótki przewodnik:

getOrElse: podanie wartości domyślnej tego samego typu
orElse: podanie zastępczej opcji
fold: przekształcenie wartości i podanie wartości domyślnej w jednym kroku
dopasowanie wzorca: gdy każdy przypadek wymaga bardziej rozbudowanej logiki

Łączenie z map

Typowy idiom polega najpierw na użyciu map do przekształcenia wartości, a następnie getOrElse, aby otrzymać zwykłą wartość.

object Main {
  def main(args: Array[String]): Unit = {
    val name: Option[String] = Some("ada")
    val display = name.map(_.toUpperCase).getOrElse("ANON")
    println(display)
  }
}

Złożenie wszystkiego w całość

Wyszukaj wartość konfiguracji, podaj zastępczą opcję, a następnie uzyskaj wartość domyślną za pomocą getOrElse.

object Main {
  val env = Map("timeout" -> "30")
  def main(args: Array[String]): Unit = {
    val timeout = env.get("timeout")
      .flatMap(_.toIntOption)
      .getOrElse(60)
    println(timeout)
    val retries = env.get("retries").fold(3)(_.toInt)
    println(retries)
  }
}

Szybkie sprawdzenie

Sprawdź swoje rozumienie bezpiecznego wyodrębniania wartości z Option.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyli się Państwo bezpiecznie wyodrębniać wartości z Option:

getOrElse(default) zwraca wartość albo wartość domyślną (obliczaną leniwie)
orElse(fallback) zwraca pierwszą wartość Some albo zastępczą opcję
fold(default)(f) przekształca Some i w jednym kroku ustawia wartość domyślną dla None
Proszę unikać get, które zgłasza wyjątek dla None

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „getOrElse i fold” jest bezpłatna?

Tak — pełny tekst „getOrElse i fold” 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 „getOrElse i fold”?

Wyodrębnianie wartości Ć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 4.

Ile czasu zajmuje lekcja „getOrElse i fold”?

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