Les tableaux sont une structure de données très courante.
Il existe d'ailleurs tout un ensemble de méthodes pour les manipuler, notamment pour les trier, les inverser, y insérer des éléments, et bien d'autres choses encore.
Certaines de ces méthodes sont destructives, c'est-à-dire qu'elles modifient le tableau d'origine.
D'autres ne le sont pas : elles renvoient un nouveau tableau sans toucher à l'original.
Voici quelques-unes des méthodes les plus courantes pour manipuler les tableaux :
insert
Pour insérer un élément dans un tableau, on peut utiliser la méthode insert, qui prend un indice et un élément en arguments.
L'élément est inséré à l'indice indiqué, et le reste du tableau est décalé vers la droite.
Si l'indice est hors limites, une IndexError est levée.
numbers = [1, 2, 3]
numbers.insert(1, 4)
numbers # => [1, 4, 2, 3]
numbers.insert(5, 5) # => Error: Index out of bounds (IndexError)
delete
Pour supprimer un élément précis d'un tableau, on peut utiliser la méthode delete, qui prend un élément en argument.
La méthode renvoie l'élément qui a été supprimé.
Si l'élément n'est pas présent dans le tableau, la méthode renvoie nil.
numbers = [1, 2, 3]
numbers.delete(2) # => 2
numbers # => [1, 3]
first & last
Pour récupérer le premier ou le dernier élément d'un tableau, on peut utiliser les méthodes first et last.
Ces méthodes prennent un argument facultatif qui indique combien d'éléments renvoyer.
C'est plus lisible que d'utiliser l'indice 0 ou -1, ou un intervalle.
Si le tableau est vide, une Enumerable::EmptyError est levée.
numbers = [1, 2, 3]
numbers.first # => 1
numbers.last # => 3
numbers.first(2) # => [1, 2]
numbers.last(2) # => [2, 3]
empty_array = [] of Int32
empty_array.last # => Error: Empty enumerable (Enumerable::EmptyError)
reverse
Pour inverser un tableau, on peut utiliser la méthode reverse, qui renvoie un nouveau tableau dont les éléments sont dans l'ordre inverse.
Il est important de noter que reverse renvoie un nouveau tableau et ne modifie pas le tableau d'origine.
Si tu veux modifier le tableau d'origine, ajoute un ! à la fin du nom de la méthode.
numbers = [1, 2, 3]
numbers.reverse # => [3, 2, 1]
numbers # => [1, 2, 3]
numbers.reverse! # => [3, 2, 1]
numbers # => [3, 2, 1]
Concat(+)
La méthode d'ajout (<<) est utile pour ajouter des objets à un tableau.
En revanche, pour combiner deux tableaux, on peut utiliser l'opérateur +, qui renvoie un nouveau tableau contenant les éléments des deux.
[1, 2] + [3, 4] # => [1, 2, 3, 4]
Si tu ajoutes un tableau à un autre tableau, il est alors ajouté comme un seul élément.
[1, 2] << [3, 4] # => [1, 2, [3, 4]]
empty?
Pour vérifier si un tableau est vide, on peut utiliser la méthode empty?, qui renvoie true si le tableau est vide et false sinon.
C'est plus lisible que de comparer la taille du tableau à 0.
[].empty? # => true
[1, 2, 3].empty? # => false
index
Pour obtenir l'indice d'un élément dans un tableau, on peut utiliser la méthode index, qui prend un élément en argument.
Si l'élément n'est pas présent dans le tableau, la méthode renvoie nil.
numbers = [1, 2, 3]
numbers.index(2) # => 1
size
Pour connaître le nombre d'éléments d'un tableau, on peut utiliser la méthode size.
numbers = [1, 2, 3]
numbers.size # => 3
count
Pour compter le nombre de fois qu'un élément est présent dans un tableau, on peut utiliser la méthode count.
fruits = ["apple", "banana", "apple"]
fruits.count("apple") # => 2
fruits.count("banana") # => 1
fruits.count("watermelon") # => 0
sort
Pour trier un tableau, on peut utiliser la méthode sort, qui renvoie un nouveau tableau avec les éléments triés.
Comme pour reverse, cette méthode renvoie un nouveau tableau et ne modifie pas le tableau d'origine.
numbers = [3, 2, 1]
numbers.sort # => [1, 2, 3]
numbers # => [3, 2, 1]
numbers.sort! # => [1, 2, 3]
numbers # => [1, 2, 3]
Exercice d'apprentissage
