Scala for Backend Engineering & Functional Programming · Leçon

Opérations fonctionnelles sur les collections

Maîtrisez les opérations fonctionnelles courantes telles que map, filter, fold et reduce pour transformer les données.

Opérations fonctionnelles sur les collections est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. 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 3 leçons au total.

Opérations fonctionnelles : pourquoi les utiliser ?

Les opérations fonctionnelles sur les collections vous aident à transformer et à combiner des données sans modifier la collection d’origine. Cette approche favorise l’immuabilité et rend votre code plus facile à lire et à tester.

Nous allons découvrir des opérations essentielles comme map, filter, reduce et fold.

Transformer avec `map`

L’opération map applique une fonction à chaque élément d’une collection et renvoie une nouvelle collection contenant les résultats transformés. La collection d’origine reste inchangée.

Essayez d’exécuter cet exemple :

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val doubled = numbers.map(n => n * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubled")
  }
}

`map` avec différents types

map est très flexible ! Vous pouvez transformer les éléments en un type complètement différent. Ici, nous convertissons des nombres en chaînes de caractères ou nous obtenons la longueur des chaînes.

Remarquez que le résultat est une List[Int], même si l’entrée était une List[String].

object Main {
  def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bob", "Charlie")
    val lengths = names.map(name => name.length)
    println(s"Names: $names")
    println(s"Lengths: $lengths")
  }
}

Sélectionner avec `filter`

L’opération filter crée une nouvelle collection contenant uniquement les éléments qui satisfont une condition donnée (une fonction prédicat). Elle élimine les éléments indésirables.

Recherchons les nombres pairs :

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(n => n % 2 == 0)
    println(s"Original: $numbers")
    println(s"Evens: $evens")
  }
}

Autres exemples avec `filter`

Vous pouvez utiliser n’importe quelle expression booléenne comme condition de filtrage. Filtrons une liste de mots pour ne conserver que ceux qui comportent plus de 4 caractères.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "cat", "banana", "dog", "elephant")
    val longWords = words.filter(w => w.length > 4)
    println(s"Words: $words")
    println(s"Long words: $longWords")
  }
}

Combiner avec `reduce`

L’opération reduce combine tous les éléments d’une collection en un seul résultat. Elle prend une opération binaire (une fonction qui accepte deux arguments et en renvoie un) et l’applique de manière cumulative.

Ici, nous additionnons tous les éléments :

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val sum = numbers.reduce((a, b) => a + b)
    println(s"Numbers: $numbers")
    println(s"Sum: $sum")
  }
}

`reduce` pour le produit et le maximum

reduce peut effectuer différentes agrégations. Nous pouvons calculer le produit des nombres ou rechercher la valeur maximale.

Remarque : reduce déclenche une erreur sur une collection vide.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 5, 2, 8)
    val product = numbers.reduce((a, b) => a * b)
    val maxNum = numbers.reduce((a, b) => if (a > b) a else b)
    println(s"Numbers: $numbers")
    println(s"Product: $product")
    println(s"Max: $maxNum")
  }
}

La puissance de la valeur initiale avec `fold`

fold est similaire à reduce, mais avec une différence importante : elle prend une valeur initiale (également appelée « accumulateur »). Cela la rend sûre pour les collections vides et permet d’obtenir des types de résultat différents.

Additionnons les nombres en commençant par 10 :

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    // foldLeft(initialValue)(operation)
    val sumWithInitial = numbers.foldLeft(10)((acc, n) => acc + n)
    println(s"Numbers: $numbers")
    println(s"Sum (starting from 10): $sumWithInitial")
  }
}

Sens du parcours : `foldLeft` et `foldRight`

Scala propose foldLeft et foldRight. Elles diffèrent par l’ordre de traitement des éléments et par la manière dont l’accumulateur est transmis.

foldLeft(initial)(op) : traite les éléments de gauche à droite.
foldRight(initial)(op) : traite les éléments de droite à gauche.

Pour des opérations comme la concaténation de chaînes, le sens du parcours est important !

object Main {
  def main(args: Array[String]): Unit = {
    val chars = List('a', 'b', 'c')
    val leftFold = chars.foldLeft("")((acc, c) => acc + c)
    val rightFold = chars.foldRight("")((c, acc) => acc + c)
    println(s"Chars: $chars")
    println(s"foldLeft: $leftFold") // Output: abc
    println(s"foldRight: $rightFold") // Output: abc (due to string append order)

    // Example where order matters: (acc, char) => char + acc
    val rightFoldReversed = chars.foldRight("")((c, acc) => c + acc)
    println(s"foldRight (char + acc): $rightFoldReversed") // Output: abc

    // A common example where order matters is for operations like subtraction or division, but string concatenation also shows it.
  }
}

Vérification des opérations fonctionnelles

Examinez l’extrait de code Scala suivant :

val data = List(10, 20, 30, 40)
val result1 = data.map(x => x / 10)
val result2 = data.filter(x => x > 25)
val result3 = data.reduce((a, b) => a + b)

Lesquelles des affirmations suivantes sont TRUE concernant les résultats ?

Récapitulatif : la puissance des opérations fonctionnelles

Vous maîtrisez désormais les opérations fonctionnelles essentielles !

map transforme chaque élément.
filter sélectionne les éléments selon une condition.
reduce combine les éléments en un seul résultat (la collection doit être non vide).
fold combine les éléments avec une valeur initiale (et fonctionne avec les collections vides).

Ces opérations sont essentielles pour écrire du code Scala concis, immuable et puissant. Nous allons maintenant découvrir une gestion robuste des erreurs avec Option, Try et Either.

Questions Fréquemment Posées

La leçon « Opérations fonctionnelles sur les collections » est-elle gratuite ?

Oui — le texte complet de « Opérations fonctionnelles sur les collections » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Opérations fonctionnelles sur les collections » ?

Maîtrisez les opérations fonctionnelles courantes telles que map, filter, fold et reduce pour transformer les données. 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 3.

Combien de temps prend la leçon « Opérations fonctionnelles sur les collections » ?

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

Exploration approfondie des collections immuables
Opérations fonctionnelles sur les collections
Option, Try et Either pour gérer les erreurs

← Retour à Scala for Backend Engineering & Functional Programming