Scala voor backend-engineering en functioneel programmeren · Les

getOrElse en fold

Waarden extraheren

Les 3 van 413 stappen

getOrElse en fold is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Een waarde ophalen

Uiteindelijk moet je een gewone waarde uit een Option halen en iets zinnigs opgeven wanneer die None is.

Scala biedt hiervoor veilige methoden zoals getOrElse en fold.

getOrElse gebruiken

getOrElse geeft de waarde in een Some terug, of een standaardwaarde die je opgeeft wanneer die None is.

Het resultaat is altijd een gewone waarde, nooit een 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))
  }
}

De standaardwaarde is lui

De standaardwaarde in getOrElse wordt alleen geëvalueerd wanneer de Option None is. Een dure standaardwaarde kost dus niets wanneer er een waarde aanwezig is.

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

get vermijden

Option heeft een get-methode, maar die werpt een uitzondering bij None. Daarmee doe je het doel van Option teniet.

Gebruik liever getOrElse, fold of patroonmatching.

orElse voor terugvalopties

orElse werkt anders: het geeft de eerste Option terug als die een Some is; anders geeft het een terugval-Option terug.

Gebruik dit om alternatieven te proberen die zelf leeg kunnen zijn.

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

Kennismaken met fold

fold behandelt beide gevallen in één aanroep. Eerst geef je een standaardwaarde voor None op en daarna een functie voor de waarde van Some.

Het geeft één resultaat terug en transformeert de waarde wanneer die aanwezig is.

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 bij None

Wanneer de Option None is, geeft fold de standaardwaarde terug die je eerst hebt opgegeven en negeert het de transformatiefunctie.

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

fold naar een ander type

Beide vertakkingen van fold moeten hetzelfde type teruggeven, maar dat type mag verschillen van het waardetype van de Option.

Hier zetten we een Option[Int] om in een 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))
  }
}

Daartussen kiezen

Korte handleiding:

getOrElse: geef een standaardwaarde van hetzelfde type op
orElse: geef een terugval-Option op
fold: transformeer de waarde en geef in één stap een standaardwaarde op
Patroonmatching: wanneer elke situatie meer logica nodig heeft

Combineren met map

Een veelgebruikte aanpak is eerst map gebruiken om te transformeren en daarna getOrElse om op een gewone waarde uit te komen.

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

Alles samenbrengen

Zoek een configuratiewaarde op, geef een terugval-Option op en gebruik vervolgens getOrElse om op een standaardwaarde uit te komen.

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

Korte controle

Test je begrip van het ophalen van Option-waarden.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je Option-waarden veilig ophaalt:

getOrElse(default) geeft de waarde of een standaardwaarde terug (lui geëvalueerd)
orElse(fallback) geeft de eerste Some of een terugval-Option terug
fold(default)(f) transformeert een Some en gebruikt in één stap een standaardwaarde voor een None
Vermijd get, dat een uitzondering werpt bij None

Gratis beginnen

Leer Scala met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 143

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “getOrElse en fold” gratis?

Ja — de volledige tekst van “getOrElse en fold” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Wat leer ik in “getOrElse en fold”?

Waarden extraheren Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?

Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “getOrElse en fold”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?

Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Scala voor backend-engineering en functioneel programmeren