0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Option w for-comprehensions

Łączenie opcji

Option w for-comprehensions 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.

Czytelne łączenie opcji

Łańcuch kilku wywołań flatMap i map może stać się trudny do odczytania. Scala oferuje wyrażenie for-comprehension, które zapewnia czytelniejszą składnię dla tego samego rozwiązania.

Jest to cukier składniowy, który kompilator przepisuje na wywołania flatMap i map.

Podstawowe wyrażenie for-comprehension

Wewnątrz for { ... } yield ... każde x <- option wyodrębnia wartość, jeśli jest obecna. yield tworzy końcowy wynik.

Jeśli każda wartość Option to Some, otrzymują Państwo Some zawierające wynik.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Przerwanie dla None

Jeśli którykolwiek generator ma wartość None, całe wyrażenie daje wynik None. Pozostałe kroki są pomijane.

Działa to tak samo jak krótkie spięcie zapewniane przez flatMap, ale jest łatwiejsze do odczytania.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = None
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Jak wygląda desugaring

Kompilator przepisuje wyrażenie for-comprehension na flatMap i map. Te dwa fragmenty są równoważne.

Zrozumienie tego procesu pomaga przewidywać typ wyniku.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val viaFor = for { x <- a; y <- b } yield x + y
    val viaFlatMap = a.flatMap(x => b.map(y => x + y))
    println(viaFor)
    println(viaFlatMap)
  }
}

Używanie wcześniejszych wartości

Późniejsze generatory mogą odwoływać się do wartości związanych wcześniej. Dzięki temu każdy krok może zależeć od poprzedniego.

object Main {
  def main(args: Array[String]): Unit = {
    val base: Option[Int] = Some(10)
    val result = for {
      x <- base
      y <- Some(x * 2)
    } yield x + y
    println(result)
  }
}

Wiązania pośrednie

Wewnątrz wyrażenia można wprowadzać zwykłe wartości za pomocą = (bez strzałki). Jest to przydatne przy obliczeniach pośrednich.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(6)
    val result = for {
      x <- a
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

Warunki if

Wyrażenie może zawierać filtr if. Jeśli warunek nie jest spełniony, wynikiem staje się None.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(8)
    val even = for {
      x <- a
      if x % 2 == 0
    } yield x
    println(even)
    val b: Option[Int] = Some(7)
    println(for { x <- b if x % 2 == 0 } yield x)
  }
}

Łączenie wyszukiwań

Typowe zastosowanie: wyszukanie kilku kluczy i połączenie ich tylko wtedy, gdy wszystkie są obecne.

object Main {
  val data = Map("a" -> 1, "b" -> 2)
  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- data.get("a")
      y <- data.get("b")
    } yield x + y
    println(combined)
    val missing = for {
      x <- data.get("a")
      z <- data.get("c")
    } yield x + z
    println(missing)
  }
}

Dlaczego for-comprehensions?

Zapewniają one:

  • czytelne wykonywanie zależnych operacji na Option
  • automatyczne przerywanie dla None
  • takie same możliwości jak flatMap/map, ale w bardziej płaskiej formie
  • filtrowanie za pomocą if i wiązania pośrednie za pomocą =

Uzyskiwanie wartości

Wyrażenie zwraca Option, dlatego należy zakończyć je za pomocą getOrElse lub fold, aby uzyskać zwykłą wartość.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val total = (for { x <- a; y <- b } yield x + y).getOrElse(0)
    println(total)
  }
}

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

Pełny potok: przeanalizuj dwa wejścia, sprawdź warunek, połącz wyniki i podaj wartość domyślną.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("10")
      y <- parse("5")
      if y != 0
    } yield x / y
    println(result.getOrElse(-1))
  }
}

Szybkie sprawdzenie

Sprawdź swoje rozumienie wyrażeń for-comprehension dla Option.

Podsumowanie

Nauczyli się Państwo łączyć opcje za pomocą wyrażeń for-comprehension:

  • for { x <- a; y <- b } yield ... pozwala czytelnie wykonywać operacje na Option
  • Jest ono przekształcane na flatMap/map
  • Dowolne None powoduje, że cały wynik staje się None
  • Późniejsze generatory mogą używać wcześniejszych wartości; = dodaje wiązania, a if filtruje
  • Proszę zakończyć wyrażenie za pomocą getOrElse lub fold, aby uzyskać zwykłą wartość

Często zadawane pytania

Czy lekcja „Option w for-comprehensions” jest bezpłatna?

Tak — pełny tekst „Option w for-comprehensions” 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 „Option w for-comprehensions”?

Łączenie opcji Ć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 „Option w for-comprehensions”?

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. Unikanie null
  2. map i flatMap dla Option
  3. getOrElse i fold
  4. Option w for-comprehensions
← Powrót do Scala for Backend Engineering & Functional Programming