Scala for Backend Engineering & Functional Programming · Lezione

map e flatMap su Option

Comporre in sicurezza

map e flatMap su Option è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Trasformare un Option

Spesso si ha un Option e si desidera trasformare il valore se è presente, lasciando invariato None.

Il metodo map fa esattamente questo, senza dover estrarre manualmente il valore.

Utilizzare map

map applica una funzione al valore contenuto in un Some e restituisce un nuovo Some. Su None non fa nulla e restituisce 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 su None

Quando l'Option è None, map ignora completamente la funzione e rimane None.

Questa è la proprietà fondamentale di sicurezza: le trasformazioni non hanno effetto in caso di assenza.

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

Cambiare il tipo

map può trasformare il valore in un tipo diverso, proprio come avviene con le collezioni. Qui un Option[Int] diventa un 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)
  }
}

Il problema dell'annidamento

Che cosa succede se la funzione restituisce a sua volta un Option? Utilizzando map si otterrebbe un Option[Option[A]] annidato, poco pratico.

È qui che entra in gioco 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)
  }
}

Utilizzare flatMap

flatMap applica una funzione che restituisce un Option e appiattisce il risultato in un singolo Option.

Confronti questo risultato con la versione annidata della scena precedente.

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

Concatenare flatMap

Poiché ogni passaggio restituisce un Option, è possibile concatenare diverse chiamate a flatMap. Se un passaggio produce None, l'intera catena diventa 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)
  }
}

Interrompere il calcolo su None

Se un passaggio intermedio restituisce None, i passaggi successivi vengono saltati e il risultato finale è None.

Questa interruzione automatica elimina i controlli manuali su 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)
  }
}

Combinare map e flatMap

Usi flatMap per i passaggi che restituiscono un Option e map per la trasformazione semplice finale.

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

Perché map e flatMap?

Questi metodi permettono di:

Trasformare i valori senza estrarli dal contenitore
Saltare automaticamente le operazioni su None
Concatenare operazioni che potrebbero non riuscire
Evitare Option[Option[A]] annidati usando flatten

Mettere tutto insieme

Una catena realistica: cercare una chiave, analizzarla e poi trasformarla, in modo sicuro.

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

Verifica rapida

Verifichi la Sua comprensione di map e flatMap.

Riepilogo

Ha imparato a comporre gli Option:

map trasforma il valore contenuto in un Some, lasciando invariato None
flatMap applica una funzione che restituisce un Option e appiattisce il risultato
La concatenazione si interrompe restituendo None se un passaggio è None
Usi flatMap per i passaggi che restituiscono un Option e map per quelli semplici

Domande Frequenti

La lezione «map e flatMap su Option» è gratuita?

Sì — il testo completo di «map e flatMap su Option» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «map e flatMap su Option»?

Comporre in sicurezza Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «map e flatMap su Option»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming