Scala for Backend Engineering & Functional Programming · Leçon

map et flatMap sur Option

Composez en toute sécurité

map et flatMap sur Option est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Transformer un Option

Vous avez souvent un Option et souhaitez transformer la valeur si elle est présente, en laissant None intact.

La méthode map fait exactement cela, sans déballage manuel.

Utiliser map

map applique une fonction à la valeur contenue dans un Some et renvoie un nouveau Some. Sur None, il ne fait rien et renvoie 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 sur None

Lorsque l’Option est None, map ignore entièrement la fonction et reste None.

C’est la propriété de sécurité essentielle : les transformations ne font rien en cas d’absence.

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

Changer de type

map peut transformer la valeur en un type différent, comme avec les collections. Ici, un Option[Int] devient 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)
  }
}

Le problème de l’imbrication

Que se passe-t-il si votre fonction renvoie elle-même un Option ? Utiliser map vous donnerait un Option[Option[A]] imbriqué, ce qui est peu pratique.

C’est là qu’intervient 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)
  }
}

Utiliser flatMap

flatMap applique une fonction qui renvoie un Option et aplatit le résultat en un seul Option.

Comparez cette sortie à la version imbriquée de la scène précédente.

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

Enchaîner les flatMap

Comme chaque étape renvoie un Option, vous pouvez enchaîner plusieurs appels à flatMap. Si une étape produit None, toute la chaîne devient 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)
  }
}

Court-circuiter sur None

Si une étape intermédiaire renvoie None, les étapes suivantes sont ignorées et le résultat final est None.

Ce court-circuitage automatique élimine les vérifications manuelles de nullité.

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

Combiner map et flatMap

Utilisez flatMap pour les étapes qui renvoient un Option et map pour la transformation finale ordinaire.

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

Pourquoi utiliser map et flatMap ?

Ces méthodes vous permettent de :

transformer des valeurs sans les déballer
ignorer automatiquement le traitement sur None
enchaîner des opérations susceptibles d’échouer
éviter un Option[Option[A]] imbriqué grâce à l’aplatissement

Assembler le tout

Une chaîne réaliste : rechercher une clé, l’analyser, puis la transformer, le tout en toute sécurité.

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

Vérification rapide

Vérifiez votre compréhension de map et flatMap.

Récapitulatif

Vous avez appris à composer des Options :

map transforme la valeur contenue dans un Some et laisse None inchangé
flatMap applique une fonction qui renvoie un Option et aplatit le résultat
l’enchaînement aboutit à None dès qu’une étape vaut None
utilisez flatMap pour les étapes qui renvoient un Option et map pour les étapes ordinaires

Questions Fréquemment Posées

La leçon « map et flatMap sur Option » est-elle gratuite ?

Oui — le texte complet de « map et flatMap sur Option » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « map et flatMap sur Option » ?

Composez en toute sécurité Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « map et flatMap sur Option » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Scala for Backend Engineering & Functional Programming