{"id":40055,"date":"2025-09-01T12:02:01","date_gmt":"2025-09-01T12:02:01","guid":{"rendered":"https:\/\/www.railscarma.com\/?p=40055"},"modified":"2026-01-01T04:59:11","modified_gmt":"2026-01-01T04:59:11","slug":"ruby-array-methods-a-comprehensive-guide","status":"publish","type":"post","link":"https:\/\/www.railscarma.com\/fr\/blog\/ruby-array-methods-a-comprehensive-guide\/","title":{"rendered":"Ruby Array Methods : Un guide complet"},"content":{"rendered":"
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Ruby, le langage de programmation \u00e9l\u00e9gant et convivial cr\u00e9\u00e9 par Yukihiro Matsumoto (souvent appel\u00e9 Matz), est depuis longtemps r\u00e9put\u00e9 pour sa simplicit\u00e9 et sa productivit\u00e9. Au c\u0153ur des capacit\u00e9s de manipulation de donn\u00e9es de Ruby se trouve la classe Array, une collection dynamique et ordonn\u00e9e qui peut contenir un nombre illimit\u00e9 d'objets de pratiquement n'importe quel type. Que vous soyez un d\u00e9butant plongeant dans les eaux de Ruby ou un d\u00e9veloppeur chevronn\u00e9 optimisant son code pour en am\u00e9liorer les performances, il est essentiel de comprendre les m\u00e9thodes de tableaux de Ruby. Ces m\u00e9thodes vous permettent de cr\u00e9er, d'acc\u00e9der, de modifier, d'it\u00e9rer et de transformer des tableaux avec un minimum d'effort, incarnant ainsi la philosophie de Ruby qui consiste \u00e0 rendre le programmeur heureux.<\/p>

Dans cet article, nous allons nous plonger dans les m\u00e9thodes de tableaux Ruby, en explorant leur syntaxe, leurs cas d'utilisation et les meilleures pratiques. Nous aborderons la cr\u00e9ation et l'acc\u00e8s de base, les techniques de modification, l'it\u00e9ration et la transformation, la recherche et la s\u00e9lection, le tri et l'unicit\u00e9, ainsi que des op\u00e9rations plus avanc\u00e9es. \u00c0 la fin de ce cours, vous saurez comment tirer parti de ces m\u00e9thodes pour \u00e9crire un code plus propre et plus efficace. N'oubliez pas que les tableaux Ruby sont \u00e0 index z\u00e9ro, c'est-\u00e0-dire que le premier \u00e9l\u00e9ment est \u00e0 l'index 0. En Ruby, les tableaux sont mutables, se d\u00e9veloppent dynamiquement et peuvent contenir des types de donn\u00e9es mixtes, y compris d'autres tableaux ou m\u00eame des hachages.<\/p>

La classe Array de Ruby h\u00e9rite de Enumerable, qui fournit de nombreuses m\u00e9thodes d'it\u00e9ration, mais nous nous concentrerons \u00e9galement sur les m\u00e9thodes sp\u00e9cifiques \u00e0 Array. Tous les exemples supposent que vous utilisez Ruby 3.0 ou une version ult\u00e9rieure, bien que la plupart d'entre eux fonctionnent dans des versions ant\u00e9rieures. Commen\u00e7ons par cr\u00e9er des tableaux et par acc\u00e9der \u00e0 leurs \u00e9l\u00e9ments.<\/p>

Cr\u00e9er des tableaux en Ruby<\/strong><\/h3>

Avant de pouvoir manipuler des tableaux, nous devons les cr\u00e9er. Ruby propose plusieurs fa\u00e7ons intuitives d'instancier un objet tableau.<\/p>

La m\u00e9thode la plus simple consiste \u00e0 utiliser les valeurs litt\u00e9rales d'un tableau avec des crochets []<\/code>. Cette m\u00e9thode est id\u00e9ale pour initialiser un tableau avec des valeurs connues :<\/p>

rubis\nfruits = [\"pomme\", \"banane\", \"cerise\"]\nnombres = [1, 2, 3, 4, 5]\nmixte = [1, \"hello\", true, [1, 2]]  # Les tableaux peuvent s'embo\u00eeter !<\/pre>
Pour les tableaux vides, il suffit d'utiliser []<\/code>:<\/p>
rubis\nempty = []<\/pre>
Ruby fournit \u00e9galement la fonction Tableau.nouveau<\/code> pour plus de contr\u00f4le. Sans argument, elle cr\u00e9e un tableau vide :<\/p>
rubis\narr = Array.new # => []<\/pre>
Vous pouvez sp\u00e9cifier une taille :<\/p>
rubis\narr = Array.new(5) # => [nil, nil, nil, nil, nil]<\/pre>
Ou une taille et une valeur par d\u00e9faut :<\/p>
rubis\narr = Array.new(3, \"default\") # => [\"default\", \"default\", \"default\"]<\/pre>
Soyez prudent avec les valeurs par d\u00e9faut mutables, car elles peuvent entra\u00eener des comportements inattendus. Par exemple :<\/p>
rubis\narr = Array.new(3, []) # Tous les \u00e9l\u00e9ments font r\u00e9f\u00e9rence au m\u00eame tableau !\narr[0] < [[\"a\"], [\"a\"], [\"a\"]]<\/pre>
Pour \u00e9viter cela, utilisez un bloc :<\/p>
rubis\narr = Array.new(3) { [] }  # Chacun obtient un nouveau tableau\narr[0] < [[\"a\"], [], []]<\/pre>
Un autre moyen pratique consiste \u00e0 utiliser la fonction %w{}<\/code> pour les tableaux de mots (cha\u00eenes de caract\u00e8res sans guillemets ni virgules) :<\/p>
rubis\nmots = %w{un deux trois}  # => [\"un\", \"deux\", \"trois\"]<\/pre>
Pour les plages, vous pouvez les convertir directement :<\/p>
rubis\ndigits = Array(0..9) # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<\/pre>
Les m\u00e9thodes de cr\u00e9ation sont fondamentales, mais ce qui rend les tableaux puissants, ce sont les m\u00e9thodes permettant d'interagir avec leurs \u00e9l\u00e9ments. Ensuite, nous explorerons l'acc\u00e8s et le d\u00e9coupage.<\/p>
Acc\u00e8s et d\u00e9coupage d'\u00e9l\u00e9ments dans un tableau Ruby<\/strong><\/h3>
L'acc\u00e8s aux \u00e9l\u00e9ments est une op\u00e9ration essentielle. La m\u00e9thode principale est l'indexeur []<\/code>qui r\u00e9cup\u00e8re les \u00e9l\u00e9ments par index :<\/p>
rubis\narr = [\"a\", \"b\", \"c\", \"d\"]\narr[0] # => \"a\"\narr[2] # => \"c\"\narr[-1] # => \"d\" (les indices n\u00e9gatifs comptent \u00e0 partir de la fin)<\/pre>
Si l'index est hors limites, il renvoie n\u00e9ant<\/code> sans erreur :<\/p>
rubis\narr[10] # => nil<\/pre>
Pour un acc\u00e8s plus s\u00fbr, utilisez rechercher<\/code>qui soul\u00e8ve un Erreur d'index<\/code> ou autorise un d\u00e9faut :<\/p>
ruby\narr.fetch(10) # => IndexError\narr.fetch(10, \"default\") # => \"default\"<\/pre>
Le \u00e0<\/code> est similaire \u00e0 la m\u00e9thode []<\/code> mais ne prend qu'un seul index et ne prend pas en charge les plages :<\/p>
rubis\narr.at(1) # => \"b\"\narr.at(-2) # => \"c\"<\/pre>
Le d\u00e9coupage permet d'extraire des sous-ensembles. L'utilisation de []<\/code> avec une fourchette ou une paire de longueurs de d\u00e9part :<\/p>
rubis\narr[1..2] # => [\"b\", \"c\"] (intervalle inclusif)\narr[1, 2] # => [\"b\", \"c\"] (indice de d\u00e9part 1, longueur 2)\narr[1...3] # => [\"b\", \"c\"] (fin exclusive)<\/pre>
Le tranche<\/code> est un alias de cette m\u00e9thode :<\/p>
rubis\narr.slice(0, 2) # => [\"a\", \"b\"]<\/pre>
Pour un acc\u00e8s rapide aux extr\u00e9mit\u00e9s, utilisez premier<\/code> et dernier<\/code>:<\/p>
rubis\narr.first # => \"a\"\narr.last # => \"d\"\narr.first(2) # => [\"a\", \"b\"]\narr.last(2) # => [\"c\", \"d\"]<\/pre>
Ces m\u00e9thodes sont non destructives, c'est-\u00e0-dire qu'elles ne modifient pas le tableau original. L'acc\u00e8s efficace aux \u00e9l\u00e9ments est essentiel dans les boucles ou lors du traitement des donn\u00e9es, et la nature indulgente de Ruby (retour de la m\u00e9thode n\u00e9ant<\/code> au lieu d'erreurs) le rend convivial pour les d\u00e9butants tout en permettant une gestion robuste des erreurs par l'interm\u00e9diaire de rechercher<\/code>.<\/p>
Modifier les tableaux Ruby : Ajouter et supprimer des \u00e9l\u00e9ments<\/strong><\/h3>
En Ruby, les tableaux sont mutables, et les m\u00e9thodes de modification sont donc nombreuses. Commen\u00e7ons par ajouter des \u00e9l\u00e9ments.<\/p>
Pour ajouter \u00e0 la fin, utilisez pousser<\/code> (ou son alias <<<\/code>):<\/p>
rubis\narr = [1, 2, 3]\narr.push(4) # => [1, 2, 3, 4]\narr < [1, 2, 3, 4, 5]<\/pre>
Pour les \u00e9l\u00e9ments multiples :<\/p>
rubis\narr.push(6, 7) # => [1, 2, 3, 4, 5, 6, 7]<\/pre>
Pour ajouter \u00e0 l'avant, utilisez d\u00e9caler<\/code>:<\/p>
rubis\narr.unshift(0) # => [0, 1, 2, 3, 4, 5, 6, 7]<\/pre>
ins\u00e9rer<\/code> permet l'insertion \u00e0 n'importe quelle position :<\/p>
rubis\narr.insert(2, \"ins\u00e9r\u00e9\") # => [0, 1, \"ins\u00e9r\u00e9\", 2, 3, 4, 5, 6, 7]<\/pre>
Il peut prendre plusieurs arguments :<\/p>
ruby\narr.insert(1, -1, 0.5) # Ins\u00e8re \u00e0 l'index 1<\/pre>
Pour combiner des tableaux, concat<\/code> ajoute tous les \u00e9l\u00e9ments d'un autre tableau :<\/p>
rubis\nmore = [8, 9]\narr.concat(more) # => [0, 1, -1, 0.5, \"ins\u00e9r\u00e9\", 2, 3, 4, 5, 6, 7, 8, 9]<\/pre>
Note: +<\/code> cr\u00e9e un nouveau tableau, tandis que concat<\/code> modifie en place.<\/p>
Suppression d'\u00e9l\u00e9ments : pop<\/code> retire de la fin :<\/p>
rubis\narr.pop # => 9, arr now [0, 1, -1, 0.5, \"inserted\", 2, 3, 4, 5, 6, 7, 8]<\/pre>
changement<\/code> s'enl\u00e8ve par l'avant :<\/p>
ruby\narr.shift # => 0, arr now [1, -1, 0.5, \"inserted\", 2, 3, 4, 5, 6, 7, 8]<\/pre>
Pour des postes sp\u00e9cifiques, delete_at<\/code>:<\/p>
ruby\narr.delete_at(2) # => 0.5, supprime \u00e0 l'index 2<\/pre>
supprimer<\/code> supprime par valeur (toutes les occurrences) :<\/p>
rubis\narr.delete(2) # => 2, supprime tous les 2<\/pre>
Pour retirer et renvoyer une tranche, utilisez tranche<\/code>! (destructeur) :<\/p>
rubis\narr.slice !(1, 3) # => [-1, \"inserted\", 2], modifie arr<\/pre>
clair<\/code> vide le tableau :<\/p>
rubis\narr.clear # => []<\/pre>
Ces m\u00e9thodes sont destructives, sauf indication contraire (par exemple, la m\u00e9thode de l'analyse des donn\u00e9es), pop<\/code>! n'est pas n\u00e9cessaire puisque pop<\/code> est destructeur). Utiliser des bangs (!<\/code>) pour les variantes qui modifient un endroit o\u00f9 il n'y a pas de bang, comme pousser<\/code>! n'est pas courante car pousser<\/code> modifie. V\u00e9rifiez toujours s'il est n\u00e9cessaire de conserver l'original et, le cas \u00e9ch\u00e9ant, affectez-le \u00e0 une nouvelle variable.<\/p>
Pour le nettoyage, compact<\/code> supprime n\u00e9ant<\/code> valeurs :<\/p>
ruby\narr = [1, nil, 2, nil, 3]\narr.compact # => [1, 2, 3] (nouveau tableau)\narr.compact ! # Modifie en place<\/pre>
uniq<\/code> supprime les doublons :<\/p>
rubis\ndups = [1, 2, 2, 3, 1]\ndups.uniq # => [1, 2, 3]<\/pre>
Avec un bloc pour une personnalisation unique :<\/p>
rubis\ndups.uniq { |x| x.even ? }  # Groupes par logique paire\/impaire<\/pre>
La modification efficace des tableaux permet d'\u00e9viter les copies inutiles et de maintenir la performance de votre code, en particulier pour les grands ensembles de donn\u00e9es.<\/p>
It\u00e9ration et transformation des tableaux Ruby<\/strong><\/h3>
L'it\u00e9ration est le point fort de Ruby, gr\u00e2ce \u00e0 Enumerable. L'\u00e9l\u00e9ment de base chacun<\/code> c\u00e8de chaque \u00e9l\u00e9ment \u00e0 un bloc :<\/p>
rubis\narr = [1, 2, 3, 4]\narr.each { |num| puts num * 2 }\n# R\u00e9sultats : 2, 4, 6, 8<\/pre>
Il renvoie le tableau original. Pour l'ordre inverse : inverse_pour_chaque<\/code>.<\/p>
carte<\/code> (ou collecter<\/code>) transforme et renvoie un nouveau tableau :<\/p>
ruby\ndoubled = arr.map { |num| num * 2 }  # => [2, 4, 6, 8]<\/pre>
Destructeur : carte<\/code>! ou collecter<\/code>!.<\/p>
chaque_avec_index<\/code> comprend l'index :<\/p>
ruby\narr.each_with_index { |num, idx| puts \"#{idx} : #{num}\" }\n# 0 : 1, 1 : 2, etc.<\/pre>
Pour la transformation conditionnelle, combiner avec des m\u00e9thodes de s\u00e9lection ult\u00e9rieurement.<\/p>
r\u00e9duire<\/code> (ou injecter<\/code>) agr\u00e8ge les valeurs :<\/p>
ruby\nsum = arr.reduce(0) { |acc, num| acc + num }  # => 10\nproduct = arr.reduce(1) { |acc, num| acc * num }  # => 24<\/pre>
r\u00e9duire<\/code> est puissant pour les sommes, les moyennes ou les r\u00e9ductions personnalis\u00e9es.<\/p>
Ces it\u00e9rateurs favorisent la programmation de type fonctionnel, en r\u00e9duisant les effets de bord et en am\u00e9liorant la lisibilit\u00e9. Pour des raisons de clart\u00e9, pr\u00e9f\u00e9rez toujours les blocs aux boucles explicites.<\/p>
Recherche et s\u00e9lection d'\u00e9l\u00e9ments dans un tableau Ruby<\/strong><\/h3>
Recherche : inclure ?<\/code> v\u00e9rifie la pr\u00e9sence :<\/p>
rubis\narr.include ?(3) # => true<\/pre>
indice<\/code> trouve le premier index correspondant :<\/p>
rubis\narr.index(3) # => 2\narr.index { |x| x.even ? }  # => 1 (premier pair)<\/pre>
rindex<\/code> pour la derni\u00e8re occurrence :<\/p>
rubis\ndups = [1, 2, 1]\ndups.rindex(1) # => 2<\/pre>
trouver<\/code> (ou d\u00e9tecter<\/code>) renvoie le premier \u00e9l\u00e9ment correspondant :<\/p>
ruby\nfirst_even = arr.find { |x| x.even ? }  # => 2<\/pre>
trouver_tout<\/code> (ou s\u00e9lectionner<\/code>) renvoie toutes les correspondances :<\/p>
ruby\nevens = arr.select { |x| x.even ? }  # => [2, 4]<\/pre>
Destructeur : s\u00e9lectionner<\/code>! ou trouver_tout<\/code>! (ne conserve que les correspondances).<\/p>
rejeter<\/code> est le contraire :<\/p>
rubis\nodds = arr.reject { |x| x.even ? }  # => [1, 3]<\/pre>
autres ?<\/code> et tous ?<\/code> pour les contr\u00f4les bool\u00e9ens :<\/p>
rubis\narr.any ? {x| x > 3 }  # => true\narr.all ? { |x| x > 0 }  # => true<\/pre>
compter<\/code> avec des correspondances de nombre de blocs :<\/p>
ruby\narr.count { |x| x.even ? }  # => 2<\/pre>
Pour les tableaux imbriqu\u00e9s, aplatir<\/code> se d\u00e9roule :<\/p>
ruby\nnested = [1, [2, 3], 4]\nnested.flatten # => [1, 2, 3, 4]<\/pre>
assoc<\/code> recherche une cl\u00e9 dans les sous-ensembles :<\/p>
rubis\npairs = [[\"a\", 1], [\"b\", 2]]\npairs.assoc(\"b\") # => [\"b\", 2]<\/pre>
Ces m\u00e9thodes permettent de filtrer efficacement les donn\u00e9es, ce qui est essentiel pour le traitement de listes telles que les donn\u00e9es utilisateur ou les journaux.<\/p>
Trier, m\u00e9langer et autres utilitaires<\/strong><\/h3>
Tri : trier<\/code> par ordre alphab\u00e9tique ou num\u00e9rique :<\/p>
rubis\nunsorted = [3, 1, 4, 1, 5]\nunsorted.sort # => [1, 1, 3, 4, 5]\nstrings = %w{banane pomme cerise}\nstrings.sort # => [\"apple\", \"banana\", \"cherry\"]<\/pre>
Tri personnalis\u00e9 avec bloc utilisant un vaisseau spatial <=><\/code>:<\/p>
ruby\nstrings.sort { |a, b| b  a }  # Descendant : [\"cerise\", \"banane\", \"pomme\"]<\/pre>
sort_by<\/code> pour les tris complexes :<\/p>
rubis\npersonnes = [[\"Alice\", 30], [\"Bob\", 25]]\npeople.sort_by { |name, age| age }  # => [[\"Bob\", 25], [\"Alice\", 30]]<\/pre>
Destructeur : trier<\/code>!.<\/p>
Pour randomiser : m\u00e9langer<\/code>:<\/p>
ruby\narr.shuffle # Ordre al\u00e9atoire, nouveau tableau\narr.shuffle ! # En place<\/pre>
\u00e9chantillon<\/code> choisit des \u00e9l\u00e9ments au hasard :<\/p>
rubis\narr.sample # Un al\u00e9atoire\narr.sample(2) # Deux al\u00e9atoires<\/pre>
tourner<\/code> modifie les \u00e9l\u00e9ments :<\/p>
rubis\narr.rotate(1) # => [last, first, ..., second-last]<\/pre>
Pour les permutations : permutation<\/code>:<\/p>
rubis\n[1,2].permutation(2).to_a # => [[1,2], [2,1]]<\/pre>
combinaison<\/code> pour les sous-ensembles :<\/p>
rubis\n[1,2,3].combination(2).to_a # => [[1,2], [1,3], [2,3]]<\/pre>
rejoindre<\/code> convertit en cha\u00eene de caract\u00e8res :<\/p>
ruby\narr.join(\", \") # \"1, 2, 3, 4\"<\/pre>
to_s<\/code> pour une stringification de base.<\/p>
Ces utilitaires g\u00e8rent des t\u00e2ches courantes telles que l'ordonnancement des donn\u00e9es ou la randomisation dans les simulations.<\/p>
Meilleures pratiques et performances des m\u00e9thodes de tableau en Ruby<\/strong><\/h3>