Scala for Backend Engineering & Functional Programming · Leçon

Option dans les compréhensions for

Q: La leçon « Option dans les compréhensions for » est-elle gratuite ?

Oui — le texte complet de « Option dans les compréhensions for » 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.

Q: Qu'est-ce que j'apprendrai dans « Option dans les compréhensions for » ?

Chaînez des options 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.

Q: 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 4 sur 4.

Q: Combien de temps prend la leçon « Option dans les compréhensions for » ?

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.

Q: 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.

Chaînez des options

Option dans les compréhensions for est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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.

Enchaîner proprement les Options

Enchaîner plusieurs appels à flatMap et map peut rendre le code difficile à lire. La compréhension for de Scala propose une syntaxe plus claire pour exprimer la même chose.

Il s’agit d’un sucre syntaxique que le compilateur réécrit en appels à flatMap et map.

Compréhension for de base

Dans for { ... } yield ..., chaque x <- option extrait la valeur lorsqu’elle est présente. Le yield construit le résultat final.

Si chaque Option est un Some, vous obtenez un Some contenant le résultat.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Arrêt anticipé sur None

Si un générateur vaut None, toute la compréhension produit None. Les étapes restantes sont ignorées.

C’est le même arrêt anticipé que fournit flatMap, mais de façon plus lisible.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = None
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Comment le sucre syntaxique est supprimé

Le compilateur réécrit une compréhension for en flatMap et map. Ces deux extraits sont équivalents.

Comprendre cette transformation vous aide à prévoir le type du résultat.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val viaFor = for { x <- a; y <- b } yield x + y
    val viaFlatMap = a.flatMap(x => b.map(y => x + y))
    println(viaFor)
    println(viaFlatMap)
  }
}

Utiliser les valeurs précédentes

Les générateurs suivants peuvent faire référence aux valeurs liées précédemment. Chaque étape peut ainsi dépendre de la précédente.

object Main {
  def main(args: Array[String]): Unit = {
    val base: Option[Int] = Some(10)
    val result = for {
      x <- base
      y <- Some(x * 2)
    } yield x + y
    println(result)
  }
}

Liaisons intermédiaires

Vous pouvez introduire des valeurs ordinaires dans la compréhension avec = (sans flèche). C’est pratique pour effectuer des calculs intermédiaires.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(6)
    val result = for {
      x <- a
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

Gardes avec if

Une compréhension peut inclure un filtre if. Si la condition échoue, le résultat devient None.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(8)
    val even = for {
      x <- a
      if x % 2 == 0
    } yield x
    println(even)
    val b: Option[Int] = Some(7)
    println(for { x <- b if x % 2 == 0 } yield x)
  }
}

Combiner des recherches

Cas d’utilisation courant : rechercher plusieurs clés et les combiner uniquement si elles sont toutes présentes.

object Main {
  val data = Map("a" -> 1, "b" -> 2)
  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- data.get("a")
      y <- data.get("b")
    } yield x + y
    println(combined)
    val missing = for {
      x <- data.get("a")
      z <- data.get("c")
    } yield x + z
    println(missing)
  }
}

Pourquoi utiliser les compréhensions for ?

Elles vous offrent :

Un enchaînement lisible d’Option dépendants
Un arrêt anticipé automatique sur None
La même puissance que flatMap/map, dans une forme plus linéaire
Un filtrage avec if et des liaisons intermédiaires avec =

Obtenir une valeur

La compréhension produit un Option. Terminez donc avec getOrElse ou fold pour obtenir une valeur ordinaire.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val total = (for { x <- a; y <- b } yield x + y).getOrElse(0)
    println(total)
  }
}

Tout assembler

Un pipeline complet : analyser deux entrées, vérifier une condition, les combiner et fournir une valeur par défaut.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("10")
      y <- parse("5")
      if y != 0
    } yield x / y
    println(result.getOrElse(-1))
  }
}

Vérification rapide

Vérifiez votre compréhension des compréhensions for sur Option.

Récapitulatif

Vous avez appris à enchaîner les Option avec les compréhensions for :

for { x <- a; y <- b } yield ... enchaîne les Option de manière lisible
Cette construction est transformée en flatMap/map
Tout None interrompt le calcul et transforme le résultat complet en None
Les générateurs suivants peuvent utiliser les valeurs précédentes ; = ajoute des liaisons et if filtre
Terminez avec getOrElse ou fold pour obtenir une valeur ordinaire

Questions Fréquemment Posées

La leçon « Option dans les compréhensions for » est-elle gratuite ?