Elixir Language
Des listes

Syntaxe

• []
• [1, 2, 3, 4]
• [1, 2] ++ [3, 4] # -> [1,2,3,4]
• hd ([1, 2, 3, 4]) # -> 1
• tl ([1, 2, 3, 4]) # -> [2,3,4]
• [tête | queue]
• [1 | [2, 3, 4]] # -> [1,2,3,4]
• [1 | [2 | [3 | [4 | []]]]] -> [1,2,3,4]
• 'bonjour' = [? h,? e,? l,? l,? o]
• keyword_list = [a: 123, b: 456, c: 789]
• keyword_list [: a] # -> 123

Listes de mots clés

Les listes de mots-clés sont des listes où chaque élément de la liste est un tuple d'un atome suivi d'une valeur.

keyword_list = [{:a, 123}, {:b, 456}, {:c, 789}]

Une notation abrégée pour écrire des listes de mots clés est la suivante:

keyword_list = [a: 123, b: 456, c: 789]

Les listes de mots-clés sont utiles pour créer des structures de données de paires clé-valeur ordonnées, dans lesquelles plusieurs éléments peuvent exister pour une clé donnée.

Le premier élément d'une liste de mots clés pour une clé donnée peut être obtenu comme suit:

iex> keyword_list[:b]
456

Un cas d'utilisation des listes de mots clés pourrait être une séquence de tâches nommées à exécuter:

defmodule TaskRunner do
  def run_tasks(tasks) do
    # Call a function for each item in the keyword list.
    # Use pattern matching on each {:key, value} tuple in the keyword list
    Enum.each(tasks, fn
      {:delete, x} ->
        IO.puts("Deleting record " <> to_string(x) <> "...")
      {:add, value} ->
        IO.puts("Adding record \"" <> value <> "\"...")
      {:update, {x, value}} ->
        IO.puts("Setting record " <> to_string(x) <> " to \"" <> value <> "\"...")
    end)
  end
end

Ce code peut être appelé avec une liste de mots clés comme ceci:

iex> tasks = [
...>   add: "foo",
...>   add: "bar",
...>   add: "test",
...>   delete: 2,
...>   update: {1, "asdf"}
...> ]

iex> TaskRunner.run_tasks(tasks)
Adding record "foo"...
Adding record "bar"...
Adding record "test"...
Deleting record 2...
Setting record 1 to "asdf"...

Listes de char

Les chaînes dans Elixir sont des "binaires". Cependant, dans le code Erlang, les chaînes sont traditionnellement des "listes de caractères", donc lors de l'appel des fonctions Erlang, vous devrez peut-être utiliser des listes de caractères au lieu de chaînes Elixir classiques.

Alors que les chaînes régulières sont écrites à l'aide de guillemets " , les listes de caractères sont écrites à l'aide de guillemets simples ' :

string = "Hello!"
char_list = 'Hello!'

Les listes de char sont simplement des listes d'entiers représentant les points de code de chaque caractère.

'hello' = [104, 101, 108, 108, 111]

Une chaîne peut être convertie en une liste de to_charlist/1 avec to_charlist/1 :

iex> to_charlist("hello")
'hello'

Et l'inverse peut être fait avec to_string/1 :

iex> to_string('hello')
"hello"

Appeler une fonction Erlang et convertir la sortie en chaîne Elixir régulière:

iex> :os.getenv |> hd |> to_string
"PATH=/usr/local/bin:/usr/bin:/bin"

Cellules Contre

Les listes dans Elixir sont des listes liées. Cela signifie que chaque élément d'une liste consiste en une valeur, suivie d'un pointeur vers l'élément suivant de la liste. Ceci est implémenté dans Elixir en utilisant des cellules contre.

Les cellules cons sont des structures de données simples avec une valeur "gauche" et une valeur "droite", ou une "tête" et une "queue".

Un | Le symbole peut être ajouté avant le dernier élément d'une liste pour noter une liste (impropre) avec une tête et une queue données. Ce qui suit est une seule cellule avec 1 comme tête et 2 comme queue:

[1 | 2]

La syntaxe Elixir standard pour une liste est en réalité équivalente à l'écriture d'une chaîne de cellules imbriquées:

[1, 2, 3, 4] = [1 | [2 | [3 | [4 | []]]]]

La liste vide [] est utilisée comme queue d'une cellule contre pour représenter la fin d'une liste.

Toutes les listes dans Elixir sont équivalentes à la forme [head | tail] , où head est le premier élément de la liste et tail est le reste de la liste, moins la tête.

iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]
iex> head
1
iex> tail
[2, 3, 4]

Utiliser la [head | tail] notation est utile pour la correspondance de motif dans les fonctions récursives:

def sum([]), do: 0

def sum([head | tail]) do
  head + sum(tail)
end

Listes de cartographie

map est une fonction de programmation fonctionnelle qui, avec une liste et une fonction, renvoie une nouvelle liste avec la fonction appliquée à chaque élément de cette liste. Dans Elixir, la fonction map/2 trouve dans le module Enum .

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

Utiliser la syntaxe de capture alternative pour les fonctions anonymes:

iex> Enum.map([1, 2, 3, 4], &(&1 + 1))
[2, 3, 4, 5]

Se référant à une fonction avec une syntaxe de capture:

iex> Enum.map([1, 2, 3, 4], &to_string/1)
["1", "2", "3", "4"]

Chaînage des opérations de liste à l'aide de l'opérateur de tuyauterie:

iex> [1, 2, 3, 4]
...> |> Enum.map(&to_string/1)
...> |> Enum.map(&("Chapter " <> &1))
["Chapter 1", "Chapter 2", "Chapter 3", "Chapter 4"]

Liste des compréhensions

Elixir n'a pas de boucles. À la place des listes, il existe d’excellents modules Enum et List , mais il existe également des listes de compréhension.

Les compréhensions de liste peuvent être utiles pour:

• créer de nouvelles listes

iex(1)> for value <- [1, 2, 3], do: value + 1
[2, 3, 4] 

• filtrage des listes, en utilisant guard expressions de guard , mais vous les utilisez sans mot when clé when .

iex(2)> odd? = fn x -> rem(x, 2) == 1 end
iex(3)> for value <- [1, 2, 3], odd?.(value), do: value
[1, 3]

• créer carte personnalisée, à l' aide into mot - clé:

iex(4)> for value <- [1, 2, 3], into: %{}, do: {value, value + 1}
%{1 => 2, 2=>3, 3 => 4}

Exemple combiné

iex(5)> for value <- [1, 2, 3], odd?.(value), into: %{}, do: {value, value * value}
%{1 => 1, 3 => 9}

Résumé

Liste de compréhension:

• utilise pour for..do syntaxe avec des gardes supplémentaires après les virgules et into mot-clé lors du retour d'une autre structure que les listes, c'est-à-dire. carte.
• dans d'autres cas, renvoyer de nouvelles listes
• ne supporte pas les accumulateurs
• ne peut pas arrêter le traitement lorsque certaines conditions sont remplies
• guard déclarations de guard doivent être en ordre après for et avant de do ou into symboles. L'ordre des symboles n'a pas d'importance

Selon ces contraintes, les compréhensions ne sont limitées que pour un usage simple. Dans les cas plus avancés, l'utilisation des fonctions des modules Enum et List serait la meilleure idée.

Différence de liste

iex> [1, 2, 3] -- [1, 3]
[2]

-- supprime la première occurrence d'un élément de la liste de gauche pour chaque élément à droite.

Liste des membres

Utilisez in l' opérateur pour vérifier si un élément est un membre d'une liste.

iex> 2 in [1, 2, 3]
true
iex> "bob" in [1, 2, 3]
false

Conversion de listes en une carte

Utilisez Enum.chunk/2 pour regrouper des éléments en sous-listes et Map.new/2 pour le convertir en carte:

[1, 2, 3, 4, 5, 6]
|> Enum.chunk(2)
|> Map.new(fn [k, v] -> {k, v} end)

Donnerait:

%{1 => 2, 3 => 4, 5 => 6}