Apprenez Ruby

Vous pouvez trier les éléments d'un tableau en utilisant la méthode Array#sort :

Inverser les éléments d'un tableau se fait tout aussi facilement :

La méthode Array#length vous donne le nombre d'éléments d'un tableau :

Les méthodes Array#+, Array#- et Array#* se comportent logiquement :

Souvenez-vous des raccourcis +=, -= et *=. Ils fonctionnent également avec des tableaux.

Finalement, nous pouvons bien sûr afficher le contenu d'un tableau à l'écran, en utilisant l'instruction puts :

Notez également qu'il est possible de convertir un tableau en une chaine de caractères, en invoquant la méthode Array#to_s :

Selon vous, que fera ce bout de code ?

>>adresses = [ 
  [ 17, "Boulevard de la Sauvenière" ], 
  [ 2, "Place de la République Française"], 
  [ 19, "Rue de la Renaissance"] 
]
>>adresses.sort

Et ceci?

>>adresses = [ 
  [ 20, "Rue de la Renaissance" ], 
  [ 20, "Place de la République Française"] 
]
>>adresses.sort

• Affichez le contenu du tableau amis dans l'ordre inverse alphabétique.
• Vous souvenez-vous de l'exercice du chapitre 2, où vous deviez afficher à l'écran les paroles de la chanson «Un kilomètre à pied, ça use…» ? Réimplémentez votre solution, en utilisant cette fois-ci un itérateur!
• Considérez le tableau suivant :

noms = [ "laurent", "david", "stéfanie", "laura" ]

Écrivez à l'écran la liste de ces noms, avec une majuscule comme première lettre. La méthode à utiliser est String#capitalize.

Comme les hachages n'utilisent pas que des indices numériques, on utilise le mot clef (en anglais : «key») pour les identifier. Un objet représenté à travers une clef est appelé valeur (en anglais : «value»).

Donc, dans l'exemple précédent, «prénom», «nom de famille» et «pays» sont des clefs. Leurs valeurs respectives sont «Jean-Paul», «Goret» et «Belgique».

Évidemment, les hachages possèdent des itérateurs. En voici quelques-uns

III-D-2-a. Hash#each▲

amis.each do |clef, valeur|
    puts clef + " =>" + valeur
end

ville =>Houtsiplou
nom de famille =>Goret
pays =>Belgique
adresse =>Rue de l'église, 26
province =>Liège
prénom =>Jean-Paul

III-D-2-b. Hash#each_key▲

>>ami.each_key do |clef|
?>   puts clef
>>end
ville
nom de famille
pays
adresse
province
prénom

III-D-2-c. Hash#each_value▲

>>ami.each_value do |valeur|
?>   puts valeur
>>end
Houtsiplou
Goret
Belgique
Rue de l'église, 26
Liège
Jean-Paul

Il nous faut commencer par déterminer le type d'informations que notre carnet d'adresses devrait référencer :

1. Le carnet d'adresses doit contenir une liste de personnes. Nous devrions être capables de trier ces personnes par ordre alphabétique ;
2. Chaque personne possède évidemment un prénom, un nom de famille, un numéro de téléphone ainsi qu'une adresse ;
3. Chaque adresse est définie par le nom d'une rue, d'un code postal ainsi que d'une ville et le pays dans lequel elle se situe.

Nous allons commencer par définir une structure représentant une adresse, et nous finirons par assembler le carnet tout entier.

Nous avons ici deux possibilités pour implémenter la structure d'une adresse :

1. Tableau : nous pourrions ajouter successivement l'adresse, le code postal, la ville et le pays dans un tableau. Ça fonctionnerait ;
2. Hachage : évidemment, c'est plus facile de se souvenir d'une expression comme adresse[« ville »] plutôt que adresse[2].

Nous allons évidemment choisir d'utiliser un hachage. Voici la représentation de nos adresses :

# Adresse de Nicolas
adresse_de_nicolas = {
    "rue"         =>"Rue du port, 32",
    "code postal" =>"56000",
    "ville"       =>"Vannes",
    "pays"        =>"France"
}
 
# Adresse de François
adresse_de_francois = {
    "rue"         =>"Avenue de la tranchée, 14",
    "code postal" =>"1000",
    "ville"       =>"Bruxelles",
    "pays"        =>"Belgique"
}
 
# Adresse de Marina
adresse_de_marina = {
    "rue"         =>"Strada di l'amore, 61",
    "code postal" =>"50100",
    "ville"       =>"Firenze",
    "pays"        =>"Italia"
}

Chaque personne est identifiée par un prénom, un nom de famille, un numéro de téléphone ainsi qu'une adresse. Comme pour la structure précédente, un hachage convient parfaitement. Voici comment nous pouvons représenter nos amis avec Ruby :

# Nicolas
nicolas = {
    "prénom"         =>"Nicolas",
    "nom de famille" =>"Rocher",
    "téléphone"      =>"(+33) 02 93 45 49 19",
    "adresse"        =>adresse_de_nicolas
}
 
# François
francois = {
    "prénom"         =>"François",
    "nom de famille" =>"Willemart",
    "téléphone"      =>"(+32) 02 679 24 81",
    "adresse"        =>adresse_de_francois
}
 
# Marina
marina = {
    "prénom"         =>"Marina",
    "nom de famille" =>"Nantini",
    "téléphone"      =>"(+39) 055 681 32 11",
    "adresse"        =>adresse_de_marina
}

Maintenant que nous avons défini toutes les autres structures, il ne nous reste plus qu'à créer le carnet d'adresses. Comme nous désirons pouvoir par la suite trier les éléments, nous devons donc utiliser un tableau pour réunir nos trois amis :

carnet = [ nicolas, francois, marina ]

Et voilà ! Nous venons d'implémenter complètement la structure de notre carnet d'adresses. Dans la section suivante, nous allons apprendre comment trier les éléments du carnet, ainsi que d'autres petites choses amusantes.

1. Ajoutez un de vos amis dans le carnet d'adresses.
2. Modifiez la structure du carnet d'adresses afin qu'il puisse contenir des adresses e-mail.

Nous pouvons toujours taper puts carnet, mais le résultat n'est pas très lisible pour un être humain (essayez dans IRB par vous-même). Nous voudrions mieux définir notre propre moyen pour afficher son contenu.

Comme carnet est un tableau, nous pouvons utiliser l'itérateur Array#each. Commençons par simplement afficher le prénom de nos amis :

carnet.each do |personne|
    puts personne["prénom"]
end

Ce qui affichera :

Nicolas
François
Marina

La prochaine étape est d'afficher les noms complets :

carnet.each do |personne|
    prenom = personne["prénom"]
    nom    = personne["nom de famille"]
    puts prenom + " " + nom
end

Nicolas Rocher
François Willemart
Marina Nantini

Rajouter le numéro de téléphone n'est pas plus difficile :

carnet.each do |personne|
    prenom = personne["prénom"]
    nom    = personne["nom de famille"]
    tel    = personne["téléphone"]
    puts prenom + " " + nom
    puts "    " + tel
end

Le résultat :

Nicolas Rocher
    (+33) 02 93 45 49 19
François Willemart
    (+32) 02 679 24 81
Marina Nantini
    (+39) 055 681 32 11

Finalement, il ne nous reste plus qu'à afficher les adresses. Voici le code qui devrait effectuer cette requête, en prenant soin d'espacer chaque personne par une nouvelle ligne :

carnet.each do |personne|
    # Nom et téléphone
    prenom = personne["prénom"]
    nom    = personne["nom de famille"]
    tel    = personne["téléphone"]
 
    puts prenom + " " + nom
    puts "    " + tel
 
    # Adresse
    rue    = personne["adresse"]["rue"]
    cp     = personne["adresse"]["code postal"]
    ville  = personne["adresse"]["ville"]
    pays   = personne["adresse"]["pays"]
 
    puts "    " + rue
    puts "    " + cp + ", " + ville
    puts "    " + pays
 
    # Une ligne vide pour séparer les entrées
    puts ""
end

Ce qui produira :

Nicolas Rocher
    (+33) 02 93 45 49 19
    Rue du port, 32
    56000, Vannes
    France
 
François Willemart
    (+32) 02 679 24 81
    Avenue de la tranchée, 14
    1000, Bruxelles
    Belgique
 
Marina Nantini
    (+39) 055 681 32 11
    Strada di l'amore, 61
    50100, Firenze
    Italia

Et voilà le travail !

Nous avons déjà utilisé Array#sort pour trier des tableaux contenant des nombres entiers, et des chaines de caractères. Mais comment pouvons-nous trier des tableaux contenant des structures de données plus complexes (comme nos hachages) ?

Lorsque le comportement par défaut n'est pas ce que vous désirez, Array#sort vous permet de spécifier comment trier le tableau. Commençons avec un exemple beaucoup plus facile que notre carnet d'adresses actuel :

amis = [
    [ "Nicolas",  "Rocher"    ],
    [ "François", "Willemart" ],
    [ "Marina",   "Nantini"   ]
]

Nous savons que par défaut la méthode Array#sort appelée sur l'objet amis effectuera le tri en fonction du premier élément de chaque sous-tableau - dans ce cas, les prénoms. Et si nous voulions trier ces éléments par leur nom de famille ?

À l'instar des itérateurs, la méthode Array#sort peut accepter un bloc de code. Comme ceci :

amis.sort do |a, b|
    # ...
end

La méthode Array#sort attend trois comportements de ce bloc de code :

• Retourner la valeur -1 si la variable a est jugée plus petite que la variable b ;
• Retourner la valeur 0 si la variable a est jugée égale à la variable b ;
• Retourner la valeur 1 si la variable a est jugée plus grande que la variable b.

Grâce a cette information, la méthode Array#sort peut savoir exactement comment il faut trier le tableau.

Comment faire pour retourner une valeur? La valeur de retour est tout simplement la valeur de la dernière expression interprétée. Jetons un petit coup d'œil dans IRB :

Les lignes =>sont les valeurs de retour des expressions.

Trier étant une opération fort courante, il existe donc un opérateur spécialement dédié à ça. L'opérateur <=>retourne pour nous les fameuses valeurs -1, 0 et 1. Essayez ceci dans IRB :

Retournons à notre petit tableau :

amis = [
    [ "Nicolas",  "Rocher"    ],
    [ "François", "Willemart" ],
    [ "Marina",   "Nantini"   ]
]

Et à notre instruction de triage :

amis.sort do |a, b|
    # ...
end

a et b sont des éléments du tableau amis. Le comportement par défaut de Array#sort est équivalent à :

amis.sort do |a, b|
    a[0] <=>b[0]   # Tri sur le premier élément
end

Mais comme nous voulons trier sur le second élément (c'est-à-dire le nom de famille), nous devons écrire :

amis = amis.sort do |a, b|
    a[1] <=>b[1]   # Tri sur le second élément
end
# Maintenant, les éléments du tableau 'amis' sont triés sur le nom de famille.

Maintenant que nous connaissons Array#sort un peu mieux, nous sommes prêts à personnaliser le tri du carnet d'adresses. Nous avons :

carnet.sort do |personne_a, personne_b|
    # ...
end

personne_a et personne_b sont tous deux des objets provenant du même hachage. Nous pouvons donc, par exemple, les trier par ordre alphabétique sur leur prénom, en écrivant tout simplement ceci :

carnet.sort do |personne_a, personne_b|
    personne_a["prénom"] <=>personne_b["prénom"]
end

Essayez, ça fonctionne !

Écrivez le code Ruby permettant de trier chaque élément du tableau carnet en fonction du nom complet (c'est-à-dire, le prénom et le nom de famille).

Quand faut-il utiliser un tableau ? Quand faut-il utiliser un hachage ?

La structure du carnet d'adresses est un bon exemple pour répondre à ces deux questions.

• Si vos données doivent être triées, il vous faut un tableau.
• Si vos données représentent une collection de données différentes, sans aucune corrélation entre elles (par exemple, un prénom, un nom et un numéro de téléphone), il vous faut un hachage.
• Par contre, si les éléments appartiennent à la même catégorie de données (par exemple, une liste de noms), il vous faut un tableau.

Dans l'exemple du carnet d'adresses, les structures pour les adresses et les personnes contiennent des données différentes. Donc, nous les avons représentés par des hachages.

Mais le carnet lui-même contient des données du même type (des personnes), et nous voulions également être capables de trier ses éléments. Donc, représenter le carnet par un tableau était le meilleur choix.

Comme vous êtes maintenant capable d'écrire des structures de données complexes, il devient plus important que vous choisissiez de bons noms pour vos variables.

III-H-2-a. Tableaux▲

III-H-2-b. Hachages▲

N'oubliez surtout pas de rajouter des commentaires clairs dans vos programmes. Souvenez-vous, on écrit le code une fois, et on le lit une infinité de fois.

En général, il est recommandé d'éviter de déclarer des sous-structures. Néanmoins, si vous utilisez une indentation propre et des noms significatifs pour vos variables, ça peut être bon.

Jetez un coup d'œil à ces exemples :

III-H-4-a. Bien▲

# Adresse de Nicolas
adresse_de_nicolas = {
    "rue"         =>"Rue du port, 32",
    "code postal" =>"56000",
    "ville"       =>"Vannes",
    "pays"        =>"France"
}
 
# Nicolas
nicolas = {
    "prénom"         =>"Nicolas",
    "nom de famille" =>"Rocher",
    "téléphone"      =>"(+33) 02 93 45 49 19",
    "adresse"        =>adresse_de_nicolas
}

III-H-4-b. Peut mieux faire▲

# Nicolas
nicolas = {
    "prénom"          =>"Nicolas",
    "nom de famille"  =>"Rocher",
    "téléphone"       =>"(+33) 02 93 45 49 19",
    "adresse"         =>{
        "rue"         =>"Rue du port, 32",
        "code postal" =>"56000",
        "ville"       =>"Vannes",
        "pays"        =>"France"
    }
}

III-H-4-c. Pas bien▲

# Nicolas
nicolas = {
"prénom" =>"Nicolas",
"nom de famille" =>"Rocher",
"téléphone" =>"(+33) 02 93 45 49 19",
"adresse" =>{
"rue" =>"Rue du port, 32",
"code postal" =>"56000",
"ville" =>"Vannes",
"pays" =>"France"
}}