Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin · Oppitunti

null-arvon välttäminen

Optionin perusteet.

Oppitunti 1/413 vaihetta

null-arvon välttäminen on ilmainen Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssilla on yhteensä 4 oppituntia.

null-arvon ongelma

Monissa kielissä puuttuva arvo esitetään arvolla null. null aiheuttaa kuitenkin pelätyn NullPointerException-virheen, jos unohdatte tarkistaa sen.

Scala tarjoaa turvallisemman vaihtoehdon: Option-tyypin.

Mikä on Option?

Option[A] edustaa arvoa, joka saattaa olla olemassa tai puuttua. Sillä on täsmälleen kaksi tapausta:

Some(value), kun arvo on olemassa
None, kun arvoa ei ole

Tyyppi itsessään kertoo, että arvo saattaa puuttua.

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

Some-arvon luominen

Wrapatkaa olemassa oleva arvo Some-arvoon ilmaistaksenne, että se on varmasti olemassa.

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

Puuttuvan arvon esittäminen None-arvolla

None on yksittäinen arvo, jota käytetään, kun mitään arvoa ei ole. Se toimii minkä tahansa Option-tyypin kanssa.

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))
  }
}

Funktiot, jotka voivat epäonnistua

Option-arvon palauttaminen tekee tuloksen puuttumisen mahdollisuudesta eksplisiittisen tyyppimäärityksessä. Kutsuja ei voi sivuuttaa sitä.

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))
  }
}

Tarkistaminen isDefined- ja isEmpty-metodeilla

isDefined kertoo, onko Option-arvo Some, ja isEmpty kertoo, onko se 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)
  }
}

Option-arvon pattern matching

Koska Option on sealed ADT, siitä voidaan tehdä pattern matching. Tämä käsittelee sekä arvon olemassaolon että sen puuttumisen selkeästi.

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 nullable-arvoista

Jos joudutte työskentelemään koodin kanssa, joka palauttaa arvon null, wrapatkaa se muodolla Option(...). Se muuntaa null-arvon arvoksi None ja minkä tahansa oikean arvon arvoksi Some.

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

Standardikirjaston Option-palautukset

Monet sisäänrakennetut metodit palauttavat jo valmiiksi Option-arvon virheiden välttämiseksi. Esimerkiksi List.headOption käsittelee tyhjät listat turvallisesti.

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)
  }
}

Miksi Option eikä null?

Option on parempi kuin null, koska se:

Tekee puuttuvat arvot näkyviksi tyypissä
Pakottaa kutsujat käsittelemään puuttuvan arvon tapauksen
Poistaa NullPointerException-virheet
Koostuu mapin, flatMapin ja for-comprehensionien kanssa

Kokonaisuuden kokoaminen

Pieni haku, joka palauttaa Option-arvon ja käsitellään sen jälkeen turvallisesti pattern matchingilla.

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"))
  }
}

Pikatesti

Testatkaa ymmärrystänne Option-tyypistä.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte välttämään null-arvoja Option-tyypin avulla:

Option[A] on joko Some(value) tai None
Se tekee mahdollisesta puuttumisesta eksplisiittisen tyypissä
Tarkistakaa tila metodeilla isDefined/isEmpty tai pattern matchingilla
Käyttäkää Option(x)-muotoa nullable-arvojen wrapaamiseen
Kirjastometodit, kuten headOption ja Map.get, palauttavat Option-arvon

Aloita maksutta

Opi Scala tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 143

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”null-arvon välttäminen” ilmainen?

Kyllä – oppitunnin ”null-arvon välttäminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssin, päivitä CoddyKit PROhon. Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”null-arvon välttäminen”?

Optionin perusteet. Harjoittelet Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”null-arvon välttäminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunnilla?

Kyllä. Jokainen Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Scala backend-kehitykseen ja funktionaaliseen ohjelmointiin