0Pricing
Elixir & Phoenix: Scalable Backend Development · Leçon

Manipulation des collections énumérables

Découvrez comment manipuler efficacement les listes, les maps et autres collections énumérables à l’aide du module `Enum` d’Elixir.

Manipulation des collections énumérables est une leçon Elixir & Phoenix: Scalable Backend Development 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 Elixir & Phoenix: Scalable Backend Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What are Enumerable Collections?

In Elixir, an enumerable is a data structure that you can iterate over, element by element. Think of them as containers for multiple values.

Elixir's powerful Enum module provides many functions to work with these collections efficiently.

  • Lists: Ordered collections of any data type.
  • Maps: Key-value stores.
  • Ranges: Sequences of numbers.

Understanding enumerables is key to functional programming in Elixir.

Working with Elixir Lists

Lists are perhaps the most common enumerable. They are ordered and can hold mixed data types.

Let's see a simple list:

defmodule ListExample do
  def run do
    my_list = [1, "hello", :atom, 4.5]
    IO.puts "My list: #{inspect my_list}"
  end
end

ListExample.run()

Exploring Maps as Enums

Maps store data in key-value pairs. While their primary use is lookup, they are also enumerable, meaning you can iterate over their key-value pairs.

When you iterate a map, each element is a tuple {key, value}.

defmodule MapExample do
  def run do
    my_map = %{name: "Alice", age: 30}
    IO.puts "My map: #{inspect my_map}"
  end
end

MapExample.run()

Introducing the `Enum` Module

The Enum module is Elixir's standard library for working with all types of enumerables. It provides a consistent interface for common operations.

Instead of writing loops, you use Enum functions to transform, filter, and aggregate collections in an immutable, functional way.

  • No changing data in place.
  • Functions return new collections.
  • Promotes clear and concise code.

Performing Actions with `Enum.each`

Enum.each/2 is used when you want to perform a side effect for each element in an enumerable, like printing to the console. It always returns :ok.

It's similar to a for-each loop in other languages, but it's purely for side effects.

defmodule EachExample do
  def run do
    numbers = [1, 2, 3]
    IO.puts "Using Enum.each:"
    Enum.each(numbers, fn num -> IO.puts "Number: #{num}" end)
  end
end

EachExample.run()

Transforming Data with `Enum.map`

Enum.map/2 applies a given function to each element of an enumerable and collects the results into a new list. This is perfect for transforming data.

The original enumerable remains unchanged, sticking to functional programming principles.

defmodule MapTransformExample do
  def run do
    numbers = [1, 2, 3]
    doubled_numbers = Enum.map(numbers, fn num -> num * 2 end)
    IO.puts "Original: #{inspect numbers}"
    IO.puts "Doubled: #{inspect doubled_numbers}"
  end
end

MapTransformExample.run()

Selecting Elements with `Enum.filter`

Enum.filter/2 creates a new list containing only the elements for which a given function returns a "truthy" value (anything not false or nil).

Use it when you need to select a subset of elements from a collection.

defmodule FilterExample do
  def run do
    numbers = [1, 2, 3, 4, 5, 6]
    even_numbers = Enum.filter(numbers, fn num -> rem(num, 2) == 0 end)
    IO.puts "All numbers: #{inspect numbers}"
    IO.puts "Even numbers: #{inspect even_numbers}"
  end
end

FilterExample.run()

Reducing Collections with `Enum.reduce`

Enum.reduce/3 (or Enum.reduce/2) is one of the most powerful Enum functions. It "reduces" an enumerable to a single value by applying a function iteratively.

You provide an initial accumulator value and a function that takes the current element and the accumulator, returning a new accumulator.

defmodule ReduceExample do
  def run do
    numbers = [1, 2, 3, 4]
    sum = Enum.reduce(numbers, 0, fn num, acc -> num + acc end)
    IO.puts "Numbers: #{inspect numbers}"
    IO.puts "Sum: #{sum}"
  end
end

ReduceExample.run()

More `Enum` Functions to Know

The Enum module is vast! Here are a few more functions you'll find useful:

  • Enum.all?(enum, fun): Checks if all elements satisfy a condition.
  • Enum.any?(enum, fun): Checks if any element satisfies a condition.
  • Enum.take(enum, n): Returns the first n elements.
  • Enum.drop(enum, n): Returns all elements except the first n.
  • Enum.sort(enum): Sorts the elements.

Explore the official Elixir documentation for the full list!

Test Your `Enum` Knowledge

Consider the following Elixir code snippet:

defmodule QuestionCode do
  def run do
    data = [1, 2, 3, 4, 5]
    result_a = Enum.map(data, fn x -> x * 10 end)
    result_b = Enum.filter(data, fn x -> rem(x, 2) == 0 end)
    result_c = Enum.reduce(data, 0, fn x, acc -> x + acc end)
    IO.puts "A: #{inspect result_a}"
    IO.puts "B: #{inspect result_b}"
    IO.puts "C: #{inspect result_c}"
  end
end

QuestionCode.run()

Recap: Enumerable Power

Great job! You've learned the fundamentals of working with enumerable collections in Elixir.

  • Enumerables are data structures you can iterate over (lists, maps, ranges).
  • The Enum module provides powerful functions for consistent, immutable operations.
  • Key functions include each (side effects), map (transform), filter (select), and reduce (aggregate).

These functions are cornerstones of functional programming in Elixir, enabling clean and efficient data manipulation.

Questions Fréquemment Posées

La leçon « Manipulation des collections énumérables » est-elle gratuite ?

Oui — le texte complet de « Manipulation des collections énumérables » 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 Elixir & Phoenix: Scalable Backend Development, passe à CoddyKit PRO. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Manipulation des collections énumérables » ?

Découvrez comment manipuler efficacement les listes, les maps et autres collections énumérables à l’aide du module `Enum` d’Elixir. Tu pratiques Elixir & Phoenix: Scalable Backend Development 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 Elixir & Phoenix: Scalable Backend Development ?

Aucune expérience préalable n'est requise. Elixir & Phoenix: Scalable Backend Development 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 « Manipulation des collections énumérables » ?

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 Elixir & Phoenix: Scalable Backend Development ?

Oui. Chaque leçon Elixir & Phoenix: Scalable Backend Development 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

  1. Fonctions, modules et chaînage
  2. Manipulation des collections énumérables
  3. Récursion et fonctions d’ordre supérieur
  4. Évaluation paresseuse avec le module Stream
← Retour à Elixir & Phoenix: Scalable Backend Development