Scala for Backend Engineering & Functional Programming · Leçon

Transformations

map, filter, flatMap

Transformations 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 des collections

Les collections Scala sont immutables par défaut. Au lieu de les modifier, vous les transformez en nouvelles collections à l'aide de méthodes comme map, filter et flatMap.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val doubled = nums.map(_ * 2)
    println(nums)
    println(doubled)
  }
}

map : transformer chaque élément

map applique une fonction à chaque élément et renvoie une nouvelle collection de la même taille. Le type des éléments peut changer.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("scala", "rocks")
    val lengths = words.map(_.length)
    println(lengths)
  }
}

La notation abrégée avec le soulignement

Le soulignement _ est une notation abrégée pour un paramètre de fonction unique. _ * 2 signifie x => x * 2. Cette notation rend les transformations simples plus concises.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(10, 20, 30)
    println(nums.map(_ + 1))
    println(nums.map(x => x + 1))
  }
}

filter : conserver les éléments correspondants

filter conserve uniquement les éléments pour lesquels le prédicat renvoie true. Le résultat peut être plus petit que l'original.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = (1 to 10).toList
    val evens = nums.filter(_ % 2 == 0)
    println(evens)
  }
}

filterNot : l'opposé

filterNot conserve les éléments pour lesquels le prédicat vaut false. C'est le complément de filter.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5)
    println(nums.filterNot(_ % 2 == 0))
  }
}

flatMap : mapper puis aplatir

flatMap applique à chaque élément une fonction qui renvoie une collection, puis aplatit les résultats en une seule collection.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("ab", "cd")
    val chars = words.flatMap(_.toList)
    println(chars)
  }
}

map ou flatMap

Si votre fonction renvoie une collection, map produit des collections imbriquées, tandis que flatMap en produit une seule, aplatie. Choisissez selon la structure souhaitée.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3)
    println(nums.map(n => List(n, n)))
    println(nums.flatMap(n => List(n, n)))
  }
}

flatMap avec Option

Appliqué à une liste d'Option, flatMap élimine les valeurs None et désempaquette les valeurs Some : c'est une manière pratique de filtrer et de transformer en une seule opération.

object Main {
  def main(args: Array[String]): Unit = {
    val raw = List("1", "x", "3", "y")
    val parsed = raw.flatMap(_.toIntOption)
    println(parsed)
  }
}

collect : filtrer et mapper ensemble

collect prend une fonction partielle : elle conserve et transforme uniquement les éléments pour lesquels la fonction est définie, en combinant filter et map en un seul parcours.

object Main {
  def main(args: Array[String]): Unit = {
    val mixed: List[Any] = List(1, "two", 3, "four", 5)
    val ints = mixed.collect { case i: Int => i * 10 }
    println(ints)
  }
}

Enchaîner les transformations

Chaque méthode renvoyant une nouvelle collection, vous pouvez les enchaîner dans un pipeline lisible. Chaque étape transforme la sortie de la précédente.

object Main {
  def main(args: Array[String]): Unit = {
    val result = List(1, 2, 3, 4)
      .map(_ + 1)
      .filter(_ % 2 == 0)
    println(result)
  }
}

Un pipeline clair

Voici un pipeline de transformation bien organisé : filtrer les nombres pairs, les mettre au carré, puis ne conserver que les plus grands. Les pipelines se lisent comme une description du flux de données.

object Main {
  def main(args: Array[String]): Unit = {
    val result = (1 to 10).toList
      .filter(_ % 2 == 0)
      .map(x => x * x)
      .filter(_ > 10)
    println(result)
  }
}

Vérification rapide

Que renvoie List("ab", "cd").flatMap(_.toList) ?

Récapitulatif

Vous avez appris les transformations fondamentales :

map — transformer chaque élément, sans changer la taille
filter / filterNot — conserver ou éliminer selon un prédicat
flatMap — mapper puis aplatir les résultats imbriqués
collect — filtrer et mapper avec une fonction partielle
Les enchaîner pour créer des pipelines lisibles et immuables

Questions Fréquemment Posées

La leçon « Transformations » est-elle gratuite ?

Oui — le texte complet de « Transformations » 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 « Transformations » ?

map, filter, flatMap 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 « Transformations » ?

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