Fork me on GitHub

Enum

Un ensemble d’algorithmes pour énumérer sur les collections.

Table des matières

Enum

Le module Enum inclus plus de 100 fonctions pour travailler sur les collections que nous avons vues dans la leçon précédente.

Cette leçon ne couvre qu’une partie des fonctions disponibles, pour la liste complète des fonctions voir la documentation officielle du module Enum; pour l’énumération paresseuse utilisez le module Stream.

all?

Lorsque nous utilisons all?, et la plupart de fonctions du module Enum, nous fournissons une fonction à appliquer aux éléments de nos collections. Dans le cas de all?, toute la collection dois être évaluée à true sinon false sera retourné:

iex> Enum.all?(["foo", "bar", "hello"], fn(s) -> String.length(s) == 3 end)
false
iex> Enum.all?(["foo", "bar", "hello"], fn(s) -> String.length(s) > 1 end)
true

any?

Contrairement à ci-dessus, any? retournera true si au moins un élément est évalué à true:

iex> Enum.any?(["foo", "bar", "hello"], fn(s) -> String.length(s) == 5 end)
true

chunk

Si vous devez diviser vos collections en plus petits groupes d’une taille donnée, chunk est la fonction que vous recherchez:

iex> Enum.chunk([1, 2, 3, 4, 5, 6], 2)
[[1, 2], [3, 4], [5, 6]]

Il existe quelques options pour chunk que vous pouvez consulter dans la documentation officielle de chunk/2 de la fonction.

chunk_by

Si on veut grouper nos collections autrement que par taille, on peux utiliser la fonction chunk_by:

iex> Enum.chunk_by(["one", "two", "three", "four", "five"], fn(x) -> String.length(x) end)
[["one", "two"], ["three"], ["four", "five"]]

each

Pour itérer sur une collection sans produire une nouvelle valeur, on utilise each:

iex> Enum.each(["one", "two", "three"], fn(s) -> IO.puts(s) end)
one
two
three

Note: La fonction each retourne l’atom :ok.

map

Pour appliquer une fonction à chaque élément et produire une nouvelle collection, nous avons la fonction map:

iex> Enum.map([0, 1, 2, 3], fn(x) -> x - 1 end)
[-1, 0, 1, 2]

min

Trouve la valeur min d’une collection:

iex> Enum.min([5, 3, 0, -1])
-1

max

Retourne la valeur max d’une collection:

iex> Enum.max([5, 3, 0, -1])
5

reduce

Avec reduce nous pouvons réduire nos collections à une valeur. Pour cela nous passons un accumulateur optionnel (10 dans cet exemple) à notre fonction; s’il n’y a pas d’accumulateur, la première valeur est utilisée:

iex> Enum.reduce([1, 2, 3], 10, fn(x, acc) -> x + acc end)
16
iex> Enum.reduce([1, 2, 3], fn(x, acc) -> x + acc end)
6
iex> Enum.reduce(["a","b","c"], "1", fn(x,acc)-> x <> acc end)
"cba1"

sort

Le tri de collections est facilité avec deux fonctions sort. La première option utilise le tri de termes d’Elixir pour déterminer l’ordre:

iex> Enum.sort([5, 6, 1, 3, -1, 4])
[-1, 1, 3, 4, 5, 6]

iex> Enum.sort([:foo, "bar", Enum, -1, 4])
[-1, 4, Enum, :foo, "bar"]

La seconde option nous permet de fournir une fonction de tri:

# with our function
iex> Enum.sort([%{:val => 4}, %{:val => 1}], fn(x, y) -> x[:val] > y[:val] end)
[%{val: 4}, %{val: 1}]

# without
iex> Enum.sort([%{:count => 4}, %{:count => 1}])
[%{count: 1}, %{count: 4}]

uniq

uniq va supprimer les doublons de nos collections:

iex> Enum.uniq([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
[1, 2, 3, 4]

Partager cette page