Scala for Backend Engineering & Functional Programming · Lekcja

map i flatMap dla Option

Bezpieczne komponowanie

map i flatMap dla Option to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 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.

Przekształcanie Option

часто masz Option i chcesz przekształcić wartość jeśli jest obecna, pozostawiając None bez zmian.

Metoda map robi dokładnie to, bez ręcznego rozpakowywania.

Używanie map

map stosuje funkcję do wartości wewnątrz Some i zwraca nowe Some. Dla None nic nie robi i zwraca None.

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

map dla None

Gdy Option ma wartość None, map całkowicie pomija funkcję i nadal zwraca None.

To kluczowa właściwość bezpieczeństwa: przekształcenia nie wykonują żadnej operacji przy braku wartości.

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

Zmiana typu

map może przekształcić wartość na inny typ, podobnie jak w kolekcjach. Tutaj Option[Int] staje się Option[String].

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(7)
    val label = n.map(x => s"value=$x")
    println(label)
  }
}

Problem z zagnieżdżeniem

Co zrobić, gdy sama funkcja zwraca Option? Użycie map dałoby zagnieżdżone Option[Option[A]], co jest niewygodne.

Właśnie tutaj przydaje się flatMap.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val nested = n.map(half)
    println(nested)
  }
}

Używanie flatMap

flatMap stosuje funkcję zwracającą Option i spłaszcza wynik do pojedynczego Option.

Porównaj ten wynik z zagnieżdżoną wersją z poprzedniej sceny.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val flat = n.flatMap(half)
    println(flat)
  }
}

Łączenie wywołań flatMap

Ponieważ każdy krok zwraca Option, można łączyć kilka wywołań flatMap. Jeśli dowolny krok zwróci None, cały łańcuch stanie się None.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(16).flatMap(half).flatMap(half)
    println(result)
  }
}

Przerywanie po None

Jeśli pośredni krok zwróci None, kolejne kroki zostaną pominięte, a końcowym wynikiem będzie None.

To automatyczne przerwanie eliminuje ręczne sprawdzanie wartości null.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(8).flatMap(half).flatMap(half)
    println(result)
  }
}

Łączenie map i flatMap

Proszę używać flatMap w krokach, które zwracają Option, a map w przypadku końcowej zwykłej transformacji.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = Some("21").flatMap(parse).map(_ * 2)
    println(result)
  }
}

Dlaczego map i flatMap?

Metody te pozwalają:

przekształcać wartości bez ich rozpakowywania
automatycznie pomijać dalsze operacje dla None
łączyć operacje, które mogą się nie powieść
unikać zagnieżdżonego Option[Option[A]] za pomocą flatten

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

Realistyczny łańcuch: wyszukanie klucza, jego analiza, a następnie przekształcenie — wszystko bezpiecznie.

object Main {
  val config = Map("port" -> "8080")
  def main(args: Array[String]): Unit = {
    val port = config.get("port").flatMap(_.toIntOption).map(_ + 1)
    println(port)
    val missing = config.get("host").flatMap(_.toIntOption)
    println(missing)
  }
}

Szybkie sprawdzenie

Sprawdź swoje rozumienie metod map i flatMap.

Podsumowanie

Nauczyli się Państwo łączyć wartości typu Option:

map przekształca wartość wewnątrz Some, pozostawiając None bez zmian
flatMap stosuje funkcję zwracającą Option i spłaszcza wynik
Łączenie operacji kończy się wynikiem None, jeśli dowolny krok ma wartość None
Proszę używać flatMap w krokach zwracających Option, a map w zwykłych krokach

Często zadawane pytania

Czy lekcja „map i flatMap dla Option” jest bezpłatna?

Tak — pełny tekst „map i flatMap dla Option” 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 „map i flatMap dla Option”?

Bezpieczne komponowanie Ć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 2 z 4.

Ile czasu zajmuje lekcja „map i flatMap dla Option”?

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