Comment travailler avec les tableaux en Ruby

Introduction

Un tableau est une structure de données qui représente une liste de valeurs, appelées éléments. Les tableaux vous permettent de stocker plusieurs valeurs dans une seule variable. En Ruby, les tableaux peuvent contenir n’importe quel type de données, y compris des nombres, des chaînes de caractères et d’autres objets Ruby. Cela peut condenser et organiser votre code, le rendant plus lisible et plus facile à maintenir. Tous les tableaux sont des objets avec leurs propres méthodes que vous pouvez appeler, fournissant une manière standardisée de travailler avec des ensembles de données.

Dans ce tutoriel, vous allez créer des tableaux, accéder aux valeurs qu’ils contiennent, ajouter, modifier et supprimer des éléments dans un tableau, et itérer à travers les éléments d’un tableau pour résoudre des problèmes plus complexes.

Création d’un tableau

Vous commencerez par examiner comment créer des tableaux de manière plus détaillée. À titre d’exemple, voici une liste de différentes espèces de requins. Sans tableau, vous pourriez les stocker dans des variables individuelles:

shark1 = "Hammerhead"
shark2 = "Great White"
shark3 = "Tiger"

Cette approche est verbeuse et peut rapidement devenir difficile à maintenir, car elle n’est pas très flexible. Ajouter un autre requin signifie que vous auriez à ajouter et suivre une variable supplémentaire.

Si vous utilisez un tableau, vous pouvez simplifier ces données. Pour créer un tableau dans un programme Ruby, utilisez des crochets carrés : ([]), et séparez les valeurs que vous souhaitez stocker avec des virgules :

sharks = ["Hammerhead", "Great White", "Tiger"]

Au lieu de créer trois variables séparées, vous avez maintenant une variable qui contient tous les trois requins. Dans cet exemple, vous avez utilisé des crochets carrés — [] — pour créer un tableau, et séparé chaque entrée par une virgule. Si vous deviez ajouter un requin supplémentaire, vous ajouteriez un autre requin au tableau plutôt que de créer et de gérer une nouvelle variable.

Vous pouvez imprimer tout un tableau avec l’instruction print, qui affichera le contenu du tableau:

print sharks

Output
["Hammerhead", "Great White", "Tiger"]

Si vous souhaitez créer un tableau où chaque entrée est un mot unique, vous pouvez utiliser la syntaxe %w{}, qui crée un tableau de mots:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

Cela équivaut à créer le tableau avec des crochets carrés:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

Cependant, remarquez que la méthode %w{} vous permet de sauter les guillemets et les virgules.

Les tableaux sont souvent utilisés pour regrouper des listes de types de données similaires, mais en Ruby, les tableaux peuvent contenir n’importe quelle valeur ou un mélange de valeurs. Cela inclut d’autres tableaux. Voici un exemple de tableau contenant une chaîne, une valeur nil, un entier et un tableau de chaînes:

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

Maintenant, vous allez voir comment accéder aux données stockées dans les tableaux.

Accéder aux éléments dans les tableaux

Pour accéder à un élément spécifique, ou élément d’un tableau, vous faites référence à son index, ou sa position dans le tableau. En Ruby, les indices commencent à zéro. Pour récupérer le premier élément de votre tableau sharks, vous ajoutez l’index de l’élément à la variable en utilisant des crochets :

sharks = ["Hammerhead", "Great White", "Tiger"]

Le tableau sharks a trois éléments. Voici un résumé de comment chaque élément dans le tableau sharks est indexé.

Le premier élément dans le tableau est Hammerhead, qui est indexé à 0. Le dernier élément est Tiger, qui est indexé à 2. Le comptage commence à 0 dans les indices, ce qui va à l’encontre de l’intuition naturelle de commencer à compter à partir de 1, alors gardez cela à l’esprit jusqu’à ce que cela devienne naturel.

Vous pouvez connaître le nombre d’éléments dans un tableau avec la méthode length :

sharks.length

Output
3

Bien que les indices de sharks commencent à 0 et vont jusqu’à 2, la propriété length renvoie le nombre d’éléments dans le tableau, qui est 3. Elle ne se préoccupe pas du tout des indices.

Si vous souhaitez connaître le numéro d’index d’un élément spécifique dans un tableau, comme Tiger, utilisez la méthode index().

print sharks.index("Tiger")

Output
2

Cela renvoie l’indice du premier élément contenant ce texte. Si un numéro d’indice n’est pas trouvé, comme pour une valeur qui n’existe pas, la console renverra nil:

print sharks.index("Whale")

Output
nil

Pour obtenir le dernier élément d’un tableau en Ruby, utilisez l’indice -1:

print sharks[-1]

Output
"Tiger"

Ruby fournit également les méthodes first et last pour obtenir les premiers et derniers éléments sans utiliser d’indices :

puts sharks.first
puts sharks.last

Output
"Hammerhead"
"Tiger"

Essayer d’accéder à un indice qui n’existe pas renverra nil:

sharks[10]

Output
nil

Les tableaux peuvent contenir d’autres tableaux, appelés tableaux imbriqués. C’est une façon de modéliser des ensembles de données bidimensionnels dans un programme. Voici un exemple de tableau imbriqué:

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

Pour accéder aux éléments d’un tableau imbriqué, vous ajouteriez un autre numéro d’indice correspondant au tableau interne. Par exemple, pour récupérer la valeur corail de ce tableau imbriqué, vous utiliseriez l’instruction suivante:

print nested_array[1][0];

Output
coral

Dans cet exemple, vous avez accédé au tableau à la position 1 de la variable nested_array, ce qui a renvoyé le tableau ["corail", "récif"]. Vous avez ensuite accédé aux éléments à la position 0 de ce tableau, qui était "corail".

Maintenant, voyons comment ajouter des éléments à un tableau.

Ajout d’éléments aux tableaux

Vous avez trois éléments dans votre tableau sharks, qui sont indexés de 0 à 2 :

sharks = ["Hammerhead", "Great White", "Tiger"]

Il existe plusieurs façons d’ajouter un nouvel élément. Vous pouvez attribuer une valeur à l’index suivant, qui dans ce cas serait 3:

sharks[3] = "Whale";

print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale"]

Cette méthode est cependant sujette aux erreurs. Si vous ajoutez un élément et omettez accidentellement un index, cela créera un élément nil dans le tableau.

sharks[5] = "Sand";

print sharks;

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

Essayer d’accéder à l’élément supplémentaire du tableau renverra sa valeur, qui sera nil:

sharks[4]

Output
nil

La recherche du prochain index disponible dans un tableau est sujette aux erreurs et prend du temps supplémentaire. Évitez les erreurs en utilisant la méthode push, qui ajoute un élément à la fin d’un tableau:

sharks.push("Thresher")
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

Vous pouvez également utiliser la syntaxe << au lieu de la méthode push pour ajouter un élément à la fin d’un tableau:

sharks << "Bullhead"

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Pour ajouter un élément au début d’un tableau, utilisez la méthode unshift():

sharks.unshift("Angel")
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Maintenant que vous savez comment ajouter des éléments, passons à leur suppression.

Suppression d’éléments d’un tableau

Pour supprimer un élément spécifique d’un tableau, utilisez les méthodes delete ou delete_at. Dans le tableau sharks, vous avez créé un élément de tableau nil plus tôt. Maintenant, vous allez vous en débarrasser.

Tout d’abord, trouvez sa position dans le tableau. Vous pouvez utiliser la méthode index pour cela:

print sharks.index(nil)

Output
4

Ensuite, utilisez delete_at pour supprimer l’élément à l’index 4 et imprimez le tableau:

sharks.delete_at(4)
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

Le delete méthode supprime les éléments d’un tableau qui correspondent à la valeur que vous transmettez. Utilisez-le pour supprimer Whale du tableau :

sharks.delete("Whale")
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

La delete méthode supprimera toutes les occurrences de la valeur que vous transmettez, donc si votre tableau a des éléments en double, ils seront tous supprimés.

La pop méthode supprimera le dernier élément d’un tableau :

sharks.pop
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Bullhead a été supprimé en tant que dernier élément du tableau. Pour supprimer le premier élément du tableau, utilisez la méthode shift :

sharks.shift
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Thresher"]

Cette fois, Angel a été supprimé du début du tableau.

En utilisant les méthodes pop et shift, vous pouvez supprimer des éléments du début et de la fin des tableaux. L’utilisation de pop est préférable chaque fois que possible, car le reste des éléments dans le tableau conserve leurs numéros d’index d’origine.

Les méthodes delete_at, pop, et shift modifient toutes le tableau d’origine et renvoient l’élément que vous avez supprimé :

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

Output
Deleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

Vous connaissez maintenant plusieurs façons de supprimer des éléments d’un tableau. Maintenant, examinons comment modifier l’élément que vous avez déjà.

Modification des éléments existants dans les tableaux

Pour mettre à jour un élément dans le tableau, attribuez une nouvelle valeur à l’index de l’élément en utilisant l’opérateur d’attribution, tout comme vous le feriez avec une variable normale.

Donné un nouveau tableau de requins, avec "Hammerhead" à l’index 0, vous remplacerez "Hammerhead" par "Angel":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output
["Angel", "Great White", "Tiger", "Whale"]

Pour vous assurer de mettre à jour le bon élément, vous pouvez utiliser la méthode index pour localiser d’abord l’élément, tout comme vous l’avez fait pour trouver l’élément que vous vouliez supprimer.

Maintenant, vous verrez comment travailler avec tous les éléments du tableau.

Itération sur les tableaux

Ruby offre de nombreuses façons d’itérer sur un tableau, et chaque méthode que vous utilisez dépend du type de travail que vous souhaitez effectuer. Ensuite, vous explorerez comment itérer sur un tableau et afficher chacun de ses éléments.

Ruby propose la syntaxe for..in:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

Pour chaque élément dans le tableau sharks, Ruby assigne cet élément à la variable locale shark. Vous pouvez ensuite imprimer la valeur de l’élément en utilisant puts.

Vous ne verrez pas souvent for..in cependant. Les tableaux Ruby sont des objets et ils fournissent la méthode each pour travailler avec les éléments. La méthode each fonctionne de manière similaire à for..in, mais a une syntaxe différente:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

Le each méthode utilise une syntaxe que vous verrez souvent en programmation Ruby. Elle prend un bloc Ruby en tant qu’argument. Un bloc est un code qui sera exécuté ultérieurement dans le contexte de la méthode. Dans ce cas, le code est puts shark. Le mot-clé shark, encadré par les caractères de pipe (|), est la variable locale qui représente l’élément dans le tableau que le bloc accédera. Ruby attribue l’élément à cette variable et exécute le code dans le bloc. La méthode each répète ce processus pour chaque élément dans le tableau :

Output
Hammerhead
Great White
Tiger
Whale

Lorsque le bloc est seulement d’une seule ligne, vous verrez souvent les développeurs Ruby remplacer les mots-clés do et end par des accolades et condenser toute l’instruction en une seule ligne :

...
sharks.each {|shark| puts shark }

Cela produit les mêmes résultats mais utilise moins de lignes de code.

La méthode each_with_index fonctionne de manière similaire, mais elle vous donne également accès à l’index de l’élément du tableau. Ce programme utilise each_with_index pour imprimer l’index et la valeur de chaque élément :

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

Pour chaque élément dans le tableau, Ruby attribue l’élément à la variable shark et attribue l’index actuel à la variable index. Vous pouvez ensuite référencer ces deux variables dans le bloc.

Output
The index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

Vous itérerez souvent sur les éléments d’un tableau dans vos propres programmes, par exemple lorsque vous devez afficher les éléments d’une base de données sur un site web, ou lorsque vous lisez des lignes depuis un fichier et traitez leur contenu.

Conclusion

Les tableaux sont une partie extrêmement polyvalente et fondamentale de la programmation en Ruby. Dans ce tutoriel, vous avez créé des tableaux et accédé à des éléments individuels. Vous avez également ajouté, supprimé et modifié des éléments dans un tableau. Enfin, vous avez exploré deux façons d’itérer sur un tableau et d’afficher son contenu, ce qui est utilisé comme une méthode courante pour afficher des données.

Apprenez-en davantage sur les autres types de données en Ruby en lisant le tutoriel Compréhension des types de données en Ruby.