0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Unikanie null

Podstawy Option

Unikanie null 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.

Problem z null

W wielu językach brakująca wartość jest reprezentowana przez null. Jednak null powoduje osławiony NullPointerException, gdy zapomnisz ją sprawdzić.

Scala oferuje bezpieczniejszą alternatywę: typ Option.

Czym jest Option?

Option[A] reprezentuje wartość, która może być obecna lub nieobecna. Ma dokładnie dwa przypadki:

  • Some(value), gdy wartość istnieje
  • None, gdy wartości nie ma

Sam typ informuje, że wartość może być nieobecna.

object Main {
  def main(args: Array[String]): Unit = {
    val present: Option[Int] = Some(42)
    val absent: Option[Int] = None
    println(present)
    println(absent)
  }
}

Tworzenie Some

Opakuj istniejącą wartość w Some, aby zaznaczyć, że na pewno jest obecna.

object Main {
  def main(args: Array[String]): Unit = {
    val name: Option[String] = Some("Ada")
    println(name)
  }
}

Reprezentowanie braku za pomocą None

None to pojedyncza wartość używana, gdy niczego nie ma. Działa z dowolnym typem Option.

object Main {
  def lookup(found: Boolean): Option[Int] =
    if (found) Some(100) else None
  def main(args: Array[String]): Unit = {
    println(lookup(true))
    println(lookup(false))
  }
}

Funkcje, które mogą zawieść

Zwracanie Option jawnie uwzględnia możliwość braku wyniku w sygnaturze typu. Wywołujący nie może tego zignorować.

object Main {
  def findUser(id: Int): Option[String] =
    if (id == 1) Some("Grace") else None
  def main(args: Array[String]): Unit = {
    println(findUser(1))
    println(findUser(2))
  }
}

Sprawdzanie za pomocą isDefined i isEmpty

isDefined informuje, czy Option jest typu Some, a isEmpty — czy jest typu None.

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

Dopasowywanie wzorców do Option

Ponieważ Option jest sealed ADT, można używać wobec niego dopasowywania wzorców. Pozwala to jasno obsłużyć zarówno obecność, jak i brak wartości.

object Main {
  def greet(name: Option[String]): String = name match {
    case Some(n) => s"Hello, $n"
    case None    => "Hello, stranger"
  }
  def main(args: Array[String]): Unit = {
    println(greet(Some("Bo")))
    println(greet(None))
  }
}

Option z wartości nullable

Jeśli musisz pracować z kodem zwracającym null, opakuj go za pomocą Option(...). Zamienia ono null na None, a każdą rzeczywistą wartość na Some.

object Main {
  def main(args: Array[String]): Unit = {
    val maybe = Option("data")
    val nothing = Option(null)
    println(maybe)
    println(nothing)
  }
}

Biblioteka standardowa zwraca Option

Wiele wbudowanych metod zwraca już Option, zamiast narażać program na błędy. Na przykład List.headOption bezpiecznie obsługuje puste listy.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val empty = List.empty[Int]
    println(xs.headOption)
    println(empty.headOption)
  }
}

Dlaczego Option zamiast null?

Option jest lepsze od null, ponieważ:

  • Uwidacznia brak wartości w typie
  • Wymusza obsługę przypadku braku przez wywołującego
  • Eliminuje NullPointerExceptions
  • Można je łączyć z map, flatMap i for-comprehensions

Połączenie wszystkiego

Niewielkie wyszukiwanie zwracające Option, a następnie bezpiecznie obsługiwane za pomocą dopasowywania wzorców.

object Main {
  val prices = Map("apple" -> 3, "pear" -> 5)
  def priceOf(item: String): Option[Int] = prices.get(item)
  def main(args: Array[String]): Unit = {
    priceOf("apple") match {
      case Some(p) => println(s"costs $p")
      case None    => println("not for sale")
    }
    println(priceOf("banana"))
  }
}

Szybkie sprawdzenie

Sprawdź, jak rozumiesz Option.

Podsumowanie

Dowiedziałeś się, jak unikać null za pomocą Option:

  • Option[A] to Some(value) lub None
  • Jawnie informuje w typie o możliwym braku wartości
  • Sprawdzaj za pomocą isDefined/isEmpty albo dopasowywania wzorców
  • Używaj Option(x), aby opakować wartości nullable
  • Metody biblioteczne, takie jak headOption i Map.get, zwracają Option

Często zadawane pytania

Czy lekcja „Unikanie null” jest bezpłatna?

Tak — pełny tekst „Unikanie null” 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 „Unikanie null”?

Podstawy Option Ć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 „Unikanie null”?

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