Elixir - Listes et tuples

Listes (liées)

Une liste chaînée est une liste hétérogène d'éléments qui sont stockés à différents emplacements de la mémoire et sont conservés à l'aide de références. Les listes liées sont des structures de données particulièrement utilisées dans la programmation fonctionnelle.

Elixir utilise des crochets pour spécifier une liste de valeurs. Les valeurs peuvent être de n'importe quel type -

[1, 2, true, 3]

Quand Elixir voit une liste de nombres ASCII imprimables, Elixir l'affiche sous forme de liste de caractères (littéralement une liste de caractères). Chaque fois que vous voyez une valeur dans IEx et que vous n'êtes pas sûr de ce que c'est, vous pouvez utiliser lei fonction pour récupérer des informations à ce sujet.

IO.puts([104, 101, 108, 108, 111])

Les caractères ci-dessus dans la liste sont tous imprimables. Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

hello

Vous pouvez également définir des listes dans l'autre sens, en utilisant des guillemets simples -

IO.puts(is_list('Hello'))

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

true

Gardez à l'esprit que les représentations entre guillemets simples et doubles ne sont pas équivalentes dans Elixir car elles sont représentées par des types différents.

Longueur d'une liste

Pour trouver la longueur d'une liste, nous utilisons la fonction length comme dans le programme suivant -

IO.puts(length([1, 2, :true, "str"]))

Le programme ci-dessus génère le résultat suivant -

4

Concaténation et soustraction

Deux listes peuvent être concaténées et soustraites à l'aide de la ++ et --les opérateurs. Prenons l'exemple suivant pour comprendre les fonctions.

IO.puts([1, 2, 3] ++ [4, 5, 6])
IO.puts([1, true, 2, false, 3, true] -- [true, false])

Cela vous donnera une chaîne concaténée dans le premier cas et une chaîne soustraite dans le second. Le programme ci-dessus génère le résultat suivant -

[1, 2, 3, 4, 5, 6]
[1, 2, 3, true]

Tête et queue d'une liste

La tête est le premier élément d'une liste et la queue est le reste d'une liste. Ils peuvent être récupérés avec les fonctionshd et tl. Attribuons une liste à une variable et récupérons sa tête et sa queue.

list = [1, 2, 3]
IO.puts(hd(list))
IO.puts(tl(list))

Cela nous donnera la tête et la queue de la liste en sortie. Le programme ci-dessus génère le résultat suivant -

1
[2, 3]

Note - Obtenir la tête ou la queue d'une liste vide est une erreur.

Autres fonctions de liste

La bibliothèque standard Elixir fournit de nombreuses fonctions pour gérer les listes. Nous allons jeter un œil à certains de ceux-ci ici. Vous pouvez consulter le reste ici Liste .

S.no.	Nom et description de la fonction
1	delete(list, item) Supprime l'élément donné de la liste. Renvoie une liste sans l'élément. Si l'élément apparaît plus d'une fois dans la liste, seule la première occurrence est supprimée.
2	delete_at(list, index) Produit une nouvelle liste en supprimant la valeur à l'index spécifié. Les indices négatifs indiquent un décalage par rapport à la fin de la liste. Si l'index est hors limites, la liste d'origine est renvoyée.
3	first(list) Renvoie le premier élément de la liste ou nil si la liste est vide.
4	flatten(list) Aplatit la liste donnée de listes imbriquées.
5	insert_at(list, index, value) Renvoie une liste avec une valeur insérée à l'index spécifié. Notez que l'index est limité à la longueur de la liste. Les indices négatifs indiquent un décalage par rapport à la fin de la liste.
6	last(list) Renvoie le dernier élément de la liste ou nil si la liste est vide.

Tuples

Les tuples sont également des structures de données qui stockent un certain nombre d'autres structures en leur sein. Contrairement aux listes, ils stockent des éléments dans un bloc de mémoire contigu. Cela signifie que l'accès à un élément de tuple par index ou l'obtention de la taille de tuple est une opération rapide. Les index commencent à zéro.

Elixir utilise des accolades pour définir les tuples. Comme les listes, les tuples peuvent contenir n'importe quelle valeur -

{:ok, "hello"}

Longueur d'un tuple

Pour obtenir la longueur d'un tuple, utilisez le tuple_size fonctionne comme dans le programme suivant -

IO.puts(tuple_size({:ok, "hello"}))

Le programme ci-dessus génère le résultat suivant -

2

Ajout d'une valeur

Pour ajouter une valeur au tuple, utilisez la fonction Tuple.append -

tuple = {:ok, "Hello"}
Tuple.append(tuple, :world)

Cela créera et retournera un nouveau tuple: {: ok, "Hello",: world}

Insérer une valeur

Pour insérer une valeur à une position donnée, on peut soit utiliser la Tuple.insert_at fonction ou le put_elemfonction. Prenons l'exemple suivant pour comprendre la même chose -

tuple = {:bar, :baz}
new_tuple_1 = Tuple.insert_at(tuple, 0, :foo)
new_tuple_2 = put_elem(tuple, 1, :foobar)

Remarquerez que put_elem et insert_ata renvoyé de nouveaux tuples. Le tuple d'origine stocké dans la variable tuple n'a pas été modifié car les types de données Elixir sont immuables. En étant immuable, le code Elixir est plus facile à raisonner car vous n'avez jamais à vous inquiéter si un code particulier mute votre structure de données en place.

Tuples et listes

Quelle est la différence entre les listes et les tuples?

Les listes sont stockées en mémoire sous forme de listes liées, ce qui signifie que chaque élément d'une liste conserve sa valeur et pointe vers l'élément suivant jusqu'à ce que la fin de la liste soit atteinte. Nous appelons chaque paire de valeur et de pointeur une cellule contre. Cela signifie que l'accès à la longueur d'une liste est une opération linéaire: nous devons parcourir toute la liste afin de déterminer sa taille. La mise à jour d'une liste est rapide tant que nous ajoutons des éléments au début.

Les tuples, en revanche, sont stockés de manière contiguë dans la mémoire. Cela signifie que l'obtention de la taille du tuple ou l'accès à un élément par index est rapide. Cependant, la mise à jour ou l'ajout d'éléments aux tuples est coûteux car cela nécessite de copier le tuple entier en mémoire.