Embed Size (px)
Citation preview
Collège du Sacré-Cœur, Charleroi
Ruby,Langage de programmation
novateur
M. BaucyTravail Personnel Encadré
Par Benoit Daloze, 6èD
Je tiens à remercier mon professeur guide, qui m’a aidé le long de la réalisation de ce projet. Son aide a été quelque peu particulière, mais adaptée à mes besoins. J’ai particulièrement apprécié sa précision sur la mise en page. Je veux aussi remercier ma mère, qui a relu avec attention l’ensemble de ce TPE et a suivi le fil de mes idées.
Table Des Matières
1. Introduction ......................................................................................................................................................... 11.1. La programmation ......................................................................................................................................... 1 1.2. Historique ...................................................................................................................................................... 1
2. Les bases du Ruby ...............................................................................................................................................22.1. Installation ..................................................................................................................................................... 2 2.2. Test ................................................................................................................................................................ 2 2.3. Premier code .................................................................................................................................................. 3
2.3.1. A vous ! .................................................................................................................................................. 3 2.4. Des outils pour aider ...................................................................................................................................... 3 2.5. Bien commencer : avoir de l’aide par la documentation ............................................................................... 4 2.6. Ruby, un monde d’objets et de méthodes ...................................................................................................... 4
2.6.1. Méthodes ............................................................................................................................................... 4 2.6.2. Objets .................................................................................................................................................... 4 2.6.3. Classes ................................................................................................................................................... 4 2.6.4. Généralisation ....................................................................................................................................... 5
2.7. Conventions de notation ................................................................................................................................ 6 2.8. Syntaxe .......................................................................................................................................................... 6
2.8.1. Délimiteurs d’instruction et nouvelles lignes ........................................................................................ 7 2.8.2. Commentaires ........................................................................................................................................ 7 2.8.3. Méthodes ............................................................................................................................................... 7 2.8.4. Variables ................................................................................................................................................ 7 2.8.5. Mots clés ................................................................................................................................................ 8
3. Les Objets ............................................................................................................................................................ 93.1. La programmation objet ................................................................................................................................ 9 3.2. La classe Object ............................................................................................................................................. 9 3.3. Integer, nombres entiers ................................................................................................................................ 9 3.4. Float, nombres à virgule flottante ................................................................................................................ 10 3.5. String, chaînes de caractères ....................................................................................................................... 10 3.6. Symbol, chaînes simplifiées ........................................................................................................................ 10 3.7. Array, ensemble d’éléments ........................................................................................................................ 10 3.8. Hash, tableau associatif ............................................................................................................................... 11 3.9. Range, suite ................................................................................................................................................. 11 3.10. Conversions d’objets ................................................................................................................................. 11 3.11. Création d’une classe ................................................................................................................................. 12
4. Structure ............................................................................................................................................................ 144.1. Les conditions .............................................................................................................................................. 14
4.1.1. if / unless .............................................................................................................................................. 14 4.1.2. else, elsif .............................................................................................................................................. 15 4.1.3. case ...................................................................................................................................................... 15 4.1.4. Condition ternaire ? : .......................................................................................................................... 15
4.2. Les boucles .................................................................................................................................................. 16 4.2.1. loop ...................................................................................................................................................... 16 4.2.2. while / until .......................................................................................................................................... 16 4.2.3. for in .................................................................................................................................................... 16 4.2.4. retry, redo / next, break ........................................................................................................................ 16
4.3. Itérateurs ...................................................................................................................................................... 16
5. Opérateurs et expressions .................................................................................................................................175.1. Expressions .................................................................................................................................................. 17 5.2. Assignation .................................................................................................................................................. 17 5.3. Assignation parallèle ................................................................................................................................... 18 5.4. self ............................................................................................................................................................... 18 5.5. gets ............................................................................................................................................................... 18
6. Méthodes, Procs et Blocs .................................................................................................................................. 196.1. Méthodes ..................................................................................................................................................... 19
6.1.1. alias ..................................................................................................................................................... 19 6.1.2. Paramètre optionnel ............................................................................................................................ 19
6.2. Bloc ............................................................................................................................................................. 19 6.3. Proc .............................................................................................................................................................. 20
7. Modules .............................................................................................................................................................. 217.1. Héritage ....................................................................................................................................................... 21 7.2. Modules ....................................................................................................................................................... 21
7.2.1. Math .................................................................................................................................................... 21 7.2.2. Comparable ......................................................................................................................................... 22 7.2.3. Enumerable ......................................................................................................................................... 22
8. Contrôle ..............................................................................................................................................................238.1. Les exceptions ............................................................................................................................................. 23 8.2. ObjectSpace ................................................................................................................................................. 23
9. Exemple 1 : Les Polynômes .............................................................................................................................. 25
10. Exemple 2 : Les Points ....................................................................................................................................27
11. Exemple 3 : Utilisation d’ id3lib .....................................................................................................................29
12. Conclusion ........................................................................................................................................................30
13. Sources ............................................................................................................................................................. 31
14. Glossaire ...........................................................................................................................................................32
1. Introduction
Ruby est un langage de programmation, un moyen puissant d’interagir avec votre ordinateur. Ne vous êtes-vous jamais demandé ce qu’il y avait derrière ces programmes que vous utilisez, quelle était la complexité de ces mécanismes ? Ou encore comment on créait un programme ? Ce TPE répondra en partie à ces questions.
Il est organisé en 3 sections. La première vous introduit dans le concept de programmer, la suivante détaille les techniques avancées et la dernière montre quelques exemples de ma propre création.
Ruby est international, portable (il peut aussi bien fonctionner sous Windows, que Mac ou Linux) et est utilisé dans divers domaines : sites Web (Ruby on Rails1), langage de script (Google SketchUp2), logiciels d’interface graphique (Shoes3), … Je ferais ici une présentation de l’utilisation simple de Ruby. Je ne me pencherai pas sur l’utilisation d’interface graphique (fenêtres), car cela nécessite un apprentissage plus long.
Ruby est vraiment le langage le plus agréable dans lequel j’ai pu programmer. Il est tout simplement naturel et suit la pensée humaine. J’ai toujours rêvé de faire découvrir ce trésor à quelqu’un …
1.1. La programmation
Le but des langages de programmation, est de servir d’interface, de traducteur entre l’homme et l’ordinateur. Au plus bas des niveaux, un programme n’est qu’une série d’instructions. Le Ruby est un langage de haut niveau, ce qui veut dire qu’une instruction en Ruby correspond à de nombreuses instructions machine. Ruby est un langage interprété : le code source est interprété par un programme qui se charge de le traduire en langage machine, et ce en temps réel.Les seules compétences requises pour programmer en Ruby sont une connaissance minimale de l’anglais, et un certain engagement dans ce tutorial.Pour illustrer ces différents niveaux, j’utiliserai l’exemple de l’addition de 2 entiers.
• Assembleur (langage de bas niveau) : « ADD AX, BX » (en supposant AX et BX les 2 entiers)
• Ruby : « a + b »L’idée, avec Ruby, est de rendre la programmation facile, intuitive, voire amusante !
1.2. Historique
La première version du langage Ruby a été publiée en 1995, par son créateur japonais, Yukihiro Matsumoto (dit "Matz"). Celui-ci ne trouvant pas de langage qui lui plaise suffisamment, créa le Ruby sur les bases du PERL, de Python et quelques autres.
1 http://rubyonrails.org/2 Google SketchUp est un logiciel qui vous permet de créer, de modifier et de partager des modèles 3D. Ruby permet de l’utiliser de manière plus automatique. http://sketchup.google.com3 http://shoooes.net/
1
2. Les bases du Ruby
2.1. Installation
Pour commencer à utiliser Ruby, il faut l’installer. La version stable à l’heure où j’écris, est la 1.8.7, mais la branche 1.9 fait son apparition. L’entièreté de ce code est compatible pour les 2 versions. L’installation dépend de votre système d’exploitation.
Le plus simple sous Windows est d’utiliser l’installateur « One-Click ». Vous pouvez le télécharger ici : http://www.ruby-lang.org/fr/downloads/ (Cherchez « Ruby [version] One-Click Installer » sous le titre Microsoft Windows). Exécutez et suivez les instructions. Ne pas installer Ruby dans un dossier dont le nom comprend des espaces, et le laisser si possible dans C:\ruby.
Il faut maintenant ajouter l’interpréteur ruby.exe dans la variable d’environnement PATH. Pour cela, appuyez sur les touches [Windows]+[Pause], onglet Avancé, cliquez sur Variables d’environnement. Dans le cadre Variables systèmes, cherchez Path. Cliquez sur modifier, allez à la fin de la ligne en appuyant sur la touche [End] et s’il n’y a pas de « ; », ajoutez en un, suivit de C:\ruby\bin. Validez en appuyant sur OK.
2.2. Test
Testons maintenant l’installation, tapez dans la console (Démarrer – Accessoires – Invite de commandes) :ruby -vVous devriez obtenir « ruby [version] [date] [OS] ». Si ce n’est pas le cas, c’est que vous n’avez pas installé correctement Ruby, ou que ruby.exe n’est pas dans la variable d’environnement PATH.
2
2.3. Premier code
Le plus simple moyen de commencer Ruby, est d’utiliser IRB1. Pour ce faire, il faut ouvrir un terminal (voir l’annexe I) et taper :irb --simple promptDès lors, vous pouvez essayer Ruby en entrant une ligne de code, par exemple :
>> 2 + 3=> 5>> 6 - 2=> 4>> 7 / 2=> 3
Voici un résultat inattendu : 7 divisé par 2 donne 3. Cela est bien normal car Ruby effectue la division entre 2 objets Integer (nombres entiers). Il faudrait donc utiliser les objets Float (nombre à virgule flottante), pour obtenir une réponse décimale.
>> 7.0 / 2.0=> 3.5
Pour sortir de la console, écrivez simplement exit.
2.3.1. A vous !
Premier exercice : donnez-moi le résultat du triple de la somme de 4 et 5, en Ruby, bien sûr !>> 3 * (4 + 5) => 27
Les parenthèses jouent simplement leur rôle. Quand je disais que c’est intuitif…
2.4. Des outils pour aider
La plupart des programmateurs utilisent au minimum un éditeur de code spécialisé pour écrire leurs programmes. Celui-ci met en évidence la syntaxe du langage, en mettant en couleur votre code. Il a parfois d’autres fonctions évoluées. Personnellement, je n’ai pas trouvé l’éditeur par excellence pour Ruby, car il y en a beaucoup, et leur choix dépend de l’utilisation qu’on en fait. Comme éditeur de base, je vous propose SciTE, l’éditeur fourni avec l’installation, et placé dans le dossier ‘scite’ dans ‘C:\ruby’. Si vous n’avez pas SciTE, j’en mets une copie sur le CD.
Sous Windows, on peut automatiquement ouvrir les fichiers .rb avec SciTE :Clic droit → Ouvrir avec → Choisir le programme…Bouton Parcourir → Trouver ‘scite.exe’ (normalement dans C:\ruby\scite) → Bouton Ouvrir → Cocher ‘Toujours utiliser ce programme pour ouvrir ce type de fichier’ → Bouton OKVous pouvez maintenant éditer vos codes en double-cliquant sur le fichier depuis l’explorateur.
1 Interactive Ruby Shell, invite de commande interactif.
3
2.5. Bien commencer : avoir de l’aide par la documentation
Dans tout langage de programmation, la documentation est très importante, car elle permet de comprendre pourquoi le programme fonctionne comme cela, et quelle méthode pourrait être pratique pour faire telle action. La documentation est disponible sur le site web http://ruby-doc.org/. Sur le CD, se trouve un dossier Documentation qui contient les différents liens. Ruby Doc Core contient la documentation des classes de base de Ruby. N’hésitez pas à en faire un favori !Il existe aussi un moyen tout simple en tapant ‘ri [Classe]’dans un terminal.
2.6. Ruby, un monde d’objets et de méthodes
2.6.1. Méthodes
Une méthode, appelée aussi souvent fonction, est comparable à une fonction mathématique dans un sens beaucoup plus large. Par exemple, ‘+’ est la méthode d’addition. Prenons l’exemple de la fonction carré. En Ruby, elle s’écrit comme ceci :
def carre(n)
return n * n
end
Analysons ligne par ligne :• Ligne 1 : Déclaration de la méthode "carre" (sans accent !1), par le mot-clé précédent
le nom, def. Les parenthèses (optionnelles) qui suivent entourent les arguments de la méthode. Ici nous avons un seul argument : n, qui est le nombre qui sera élevé au carré.
• Ligne 2 : Multiplication du nombre par lui-même, et ce résultat est retourné (return). n*n est donc envoyé comme valeur de retour. Il est à noter que le mot-clé return est optionnel, car le résultat de la dernière instruction est toujours retourné.
• Ligne 3 : fin de la méthode, par le mot-clé end.
2.6.2. Objets
Quand aux objets, ceux-ci ne sont que les sujets auxquels on demande d’appliquer la méthode. Ici nous n’avons que des nombres. Chaque objet a ses méthodes propres. Par exemple, les nombres ont la capacité d’être multipliés par un autre nombre.
2.6.3. Classes
Les classes décrivent les objets. La classe des nombres entiers est Integer, celle des nombres à virgule flottante2 est Float, … Les méthodes de chaque objet sont définies dans leur classe. Ainsi la méthode de multiplication est définie dans ces 2 classes de nombres. On peut aussi créer des classes soi-même, voire même modifier des classes existantes. C’est ce qui fait la flexibilité de Ruby. Un chapitre sera plus tard dédicacé aux classes.
1 Voir la syntaxe des méthodes2 Floating point number
4
2.6.4. Généralisation
Généralisons : il existe des méthodes pour multiplier des nombres, afficher du texte à l’écran, parcourir un ensemble d’éléments, etc. Ces méthodes, en Ruby, dépendent toutes de l’objet, et c’est une particularité intéressante. Il n’y aurait aucun intérêt à multiplier 2 tableaux. On appelle (= on lance) la méthode d’un objet de cette manière :
objet.methode(arguments).Voici une méthode personnalisée qui dit bonjour:
1 def bonjour(nom)
2 "Bonjour " + nom
3 end
4 #puts est une méthode qui affiche le résultat à l'écran
5 puts bonjour("Benoit") #=> Affiche : Bonjour Benoit1
La ligne 1 est la déclaration de la méthode "bonjour". Ici nous avons un seul argument : nom, qui est le nom de la personne que l’on salue.La ligne 2 est l’addition (la concaténation) de 2 chaînes : "Bonjour "(avec un espace pour que le nom ne « colle » pas, et la variable nom. Comme c’est la dernière ligne dans la méthode, c’est son résultat qui est valeur de retour. En ligne 3, le mot-clé end pour fin de méthode. La ligne 4 est un commentaire, et n’est donc pas interprétée.Enfin, en ligne 5, on affiche (puts) le résultat de la méthode bonjour avec l’argument "Benoit" (Ce résultat vaut "Bonjour Benoit").‘puts’ est le raccourci de put string : Envoyer cette chaîne a la sortie standard, ici la console.
Il existe 2 types de méthodes, elles sont différenciables par la partie qui est avant le « . ».• Les méthodes de classe, qui s’appliquent de façon générale sur une classe, et dont la
syntaxe est « Class.method », comme Math.sin, Math.sqrt. Ici on aura toujours une classe avant le point, qui commence toujours par une majuscule suivie d’autres caractères alphabétiques.
Math.sqrt(9) #=> 3 # racine carrée (sqrt = square root)
Array[1, 2, 3] #=> [1, 2, 3] # crée une liste de nombres
• Les méthodes d’objets, qui s’appliquent sur des objets particuliers, comme les exemples qui suivent. Ici on aura n’importe quoi sauf une classe.
"Benoit".length #=> 6 # nombre de caractères
"a" * 3 + "h!" #=> "aaah!"
1 Ce qui suit la séquence #=> est le résultat de cette ligne.
5
2.7. Conventions de notation
Afin de faciliter la lecture, et de diminuer la longueur des phrases, ces conventions sont appliquées :
• Le texte écrit en police à largeur fixe (ici Courier New) est du code : "Ceci est du code".
• Dans le texte, Class#method fait référence à la méthode d’objet method. Tandis que Class.method fait référence à la méthode de classe method.
Dans le code Désignation de manière générale"test".length #=> 4 String#length : longueur d’une chaîne
DateTime.now #=> "2009-04-09T14:51:22+03:00"1 DateTime.now : Temps (date et heure) actuelDonc si je veux utiliser String#method, il faudra écrire quelque chose comme "machaîne".method. Tandis que String.method s’écrira obligatoirement String.method.
• Les résultats d’une ligne de code sont parfois notés après cette séquence : #=>. C’est en fait ce qu’afficherait la méthode puts.
• Les mots de ce style, font référence à un mot du glossaire en fin d’ouvrage.
2.8. Syntaxe
Chaque langage de programmation a sa syntaxe propre, qui caractérise sa manière d’effectuer des actions. Par exemple, le bien connu ‘Hello World’ s’écrit en Ruby :
puts 'Hello World'
Bien plus simple qu’en C (langage de base, qui fait tourner Ruby) :
#include <stdio.h>
int main(void) {
printf("hello, world\n");
return 0;
}
C’est donc l’interpréteur de ruby (ruby.exe) qui se charge de faire le lien entre la machine et le langage avec sa syntaxe.
La syntaxe du Ruby est faite pour être naturelle mais elle n’en est pas moins complexe. Elle est aussi très simplifiée, toutes les parenthèses qui ne sont pas nécessaires peuvent être omises (au pire le programme vous dira qu’il faut en mettre), des espaces peuvent souvent être ajoutés, … Enfin, tout est sensitif à la casse2.
1 Pour plus de lisibilité, j’ai mis ici le résultat avec DateTime#strftime2 C’est dire que les minuscules et majuscules sont différenciées.
6
2.8.1. Délimiteurs d’instruction et nouvelles lignes
Une instruction (action exécutée par l’ordinateur) s’arrête automatiquement à la fin de la ligne, sauf si elle n’est pas terminée. On peut insérer des points-virgules ‘;’ pour séparer plusieurs instructions dans la même ligne, ou au contraire, étendre une instruction sur plusieurs lignes en insérant un backslash ‘\’.
2.8.2. Commentaires
Un commentaire est un texte décrivant ce que l’on fait, afin de s’aider soi-même, ou de permettre à quelqu’un qui lit votre code de le comprendre. Il faut commenter, sinon ça devient vite casse-tête pour s’y retrouver. Mais pas trop de commentaires, par exemple ‘5 * 6’, ‘puts "Hello"’ ne se commentent pas. Il existe 2 types de commentaires : le commentaire en fin de ligne commençant par #, et le commentaire de plusieurs lignes compris entre =begin et =end, ces 2 instructions devant être placées en début de ligne.
2.8.3. Méthodes
Le nom de la méthode est composé des caractères de a à z, A à Z sans accent, peut contenir des chiffres et l’underscore « _ », mais doit commencer par une lettre.Les méthodes terminant par « ! » modifient l’objet sur lequel on l’applique (c'est-à-dire modifient le contenu). Les méthodes terminant par « ? » renvoient une valeur de vérité parmi vrai ou faux.
2.8.4. Variables
Une variable est un nom que l’on donne à une valeur, afin de la garder en mémoire. Ainsi on pourrait définir la variable PI à 3.14159… ou encore mon_nom à "Benoit" :
PI = 3.14159
mon_nom = "Benoit"
Nous avons déjà utilisé des variables comme arguments. Les variables ne sont donc que des noms qu’on donne pour stocker des objets. Il existe plusieurs types de variable :
$globale = 'disponible dans tout le code'
locale = 'disponible dans le contexte courant'
class Exemple
@@variable_de_classe = 'disponible dans la classe'
def methode
@attribut = 'disponible dans l’instance qui le possède'
end
end
CONSTANTE = 'valeur non modifiable, disponible dans le contexte courant'
Les caractères A-Za-z0-9 et l’underscore _ sont acceptés, sauf qu’une variable ne commence pas par un chiffre. Les CONSTANTES commencent par une majuscule, tandis que les variables commencent par une minuscule (ou _). On sépare les mots dans les variables en substituant l’espace à _, et on utilise la majuscule pour séparer les mots dans les Constantes et nom de classe (variable_de_plusieurs_mots, ConstanteDePlusieursMots).
7
2.8.5. Mots clés
Ces mots sont réservés et ne devraient pas être utilisés dans des noms de variable et de méthodes. Nous apprendrons leur utilité au fil du code.
=begin break elsif module retry unless
=end case end next return until
BEGIN class ensure nil self when
END def false not super while
alias defined? for or then yield
and do if redo true __FILE__
begin else in rescue undef __LINE__
8
3. Les Objets
3.1. La programmation objet
Ruby est très « orienté objet ». Tout est un objet en Ruby, et décrit par sa classe. Chaque classe définit des méthodes et les objets, qui sont les instances des classes, peuvent posséder des attributs (propriétés, valeurs). Les objets sont enregistrés dans la mémoire vive, et les variables contiennent uniquement le « numéro » de l’objet (référence). Ex : 2 est situé à l’emplacement 5 dans la mémoire. On peut donc avoir plusieurs variables pour un objet dans la mémoire. La plupart des classes sont codées en Ruby, excepté celles de base qui sont écrites en C pour des raisons de rapidité.
Nous allons voir ces classes de base, car toutes les autres en ont besoin.
3.2. La classe Object
C’est la classe de base, qui contient les méthodes communes à tous les objets et dont bon nombre d’entre elles sont redéfinies par les autres classes. Voici quelques méthodes particulièrement utiles :Méthode Description ExempleObject#class Retourne la classe 6.class #=> FixnumObject#inspect Retourne une chaîne de caractères décrivant
l’objet6.inspect #=> "6"
Object#to_s Conversion en chaîne 6.to_s #=> "6"puts Imprime à l’écran l’objet puts 6 #=> 6Passons maintenant aux classes de base.
3.3. Integer, nombres entiers
Les nombres entiers sont représentés en 2 sous-classes : Fixnum et Bignum. Ceci pour des raisons pratiques, car tous les Fixnum(de -230 à 230) sont gardés sous forme binaire, tandis que les Bignum sont actuellement représentés par un ensemble de petits nombres. Ruby se charge lui-même d’effectuer les conversions entre ces 2 classes, vous pouvez donc retenir que la classe Integer est celle des entiers1. La création d’un entier n’a rien de compliqué :
72_134_675 #=> 2134675# La classe ne se limite pas à la base 10 :
0b11 #=> 3 # 0b est le préfixe de la base 2(binaire) 0xEF #=> 239 # 0x est le préfixe de la base 16(hexadécimale) 0234 #=> 156 # 0 est le préfixe de la base 8(octale)
# Ne jamais mettre de 0 devant en base 10 !
Les principales méthodes sont les opérateurs (+, -, *, /, %)
1 Pragmatic Programmers, Programming Ruby, 2nd Edition, p.55
9
3.4. Float, nombres à virgule flottante
Les nombres réels sont gérés par la classe Float. La première chose à savoir, est que l’on place un point pour séparer les décimales, comme dans la convention anglaise ! La création est toujours aussi simple :
5.4 #=> 5.4 # Usage du point2e5 #=> 200000.0 # toujours un 0 final pour montrer que c’est un Float6.023e23 #=> 6.023e+23 # Ruby évite d’afficher les 20 zéros …
3.5. String, chaînes de caractères
Les chaînes de caractères sont simplement un ensemble de caractères (char). Il faut toujours les entourer de guillemets (quotes : ", ') afin de les délimiter. Les double-quotes permettent l’évaluation d’expression à l’intérieur de la chaîne par cette syntaxe "#{expression}" et transforment le résultat en String.
nom = 'Benoit' # assignation de Benoit à la variable nom
puts "Bonjour #{nom}" # Affiche "Bonjour Benoit" à l’écran
Certains caractères ne sont évalués qu’entre les double-quotes : "\n" un retour à la ligne, "\t" une tabulation.
3.6. Symbol, chaînes simplifiées
Les symboles, sont des chaînes de caractères simplifiées, destinées à représenter par des noms les méthodes, variables et autres dans Ruby. Leur syntaxe commence par : suivi par une lettre, un opérateur (+, *, …) ou "_". Il existe néanmoins un moyen d’y intégrer d’autres caractères en les mettant entre guillemets :"chaîne". Voici un exemple de l’utilisation du Symbol :+.
2.5.method(:+) #=> #<Method : Float#+> # la méthode d’addition des Float
3.7. Array, ensemble d’éléments
Les tableaux (Array) sont des objets qui en contiennent d’autres, généralement de même type. Le mot tableau a, dans ce contexte, 1 seule dimension, comme une liste.Une liste est ainsi représentable par une suite d’éléments, par exemple des String. L’opérateur Array#[i] permet d’accéder au i+1e élément de la liste. En effet, les index (tel que i) commencent toujours à 0 ! L’opérateur Array#[i]=value permet quant à lui de changer la valeur d’un élément, et Array#<<e permet d’ajouter un élément.
arr = [6, 'a', :sym] # Construction standard d’un tableau
arr[1] #=> 'a' # le 2ème élément
arr[2] = :bol # arr = [6, 'a', :bol]
arr << 3.5 # arr = [6, 'a', :bol, 3.5]
Il est à noter qu’un tableau peut contenir un tableau. Dès lors, on l’appelle tableau multidimensionnel.
10
3.8. Hash, tableau associatif
Un tableau associatif (Hash), n’est jamais qu’un tableau dont les index (appelés clés (keys) dans ce cas) ne sont plus des nombres, mais des objets quelconques. En général ce sont des String ou Symbol.
{ :nom => 'Daloze', :prenom => 'Benoit', :age => 18, :sexe => 'M' }
Pour comparer Array et Hash, voici le même exemple sous forme d’Array :
['Daloze', 'Benoit', 18, 'M']
Où les "clés" seraient 0, 1, 2 et 3 au lieu de, respectivement, :nom, :prenom, :age et :sexe.Ainsi, si le Hash était enregistré dans la variable h et l’Array dans arr :
h[:prenom] #=> "Benoit"
arr[1] #=> "Benoit"
3.9. Range, suite
Range permet de créer des suites de nombres, de lettres, … Sa construction se fait entre parenthèses, en séparant le début de la fin par .. ou .... 2 points incluent les 2 bornes, tandis que 3 excluent la borne de fin.
a = (1..3) #=> semblable à [1, 2, 3]
b = (1...3) #=> semblable à [1, 2]
a.include? 3 #=> true
b.include? 3 #=> false
('a'...'e').to_a #=> ["a", "b", "c", "d"] # to_a convertit en Array
3.10. Conversions d’objets
Parfois, il est utile de convertir un objet en un autre, ou d’obtenir une représentation sous une autre forme. Par exemple convertir un Integer en Float (2.to_f #=> 2.0). Mais on perd parfois de l’information, comme en convertissant un Float en Integer (6.73.to_i #=> 6). Voici les conversions de base : to_s convertit en String, to_a en Array, to_f en Float, to_i en Integer.
11
3.11. Création d’une classe
Il est maintenant temps de créer notre propre classe. Je prendrai ici l’exemple des points à 2 coordonnées, car cet exemple est simple. Voici le code :
1 class Point
2 attr_reader :x, :y
3 def initialize(x, y)
4 @x, @y = x, y
5 end
6 def +(p)
7 Point.new(@x+p.x, @y+p.y)
8 end
9 def self.O
10 Point.new(0, 0)
11 end
12 def to_s
13 "#{@x},#{@y}"
14 end
15 end
L’instanciation d’une classe, c’est-à-dire le fait d’obtenir une instance (un objet d’une classe), ne se fait pas toujours aussi facilement que l’on vient de voir. Par exemple, pour instancier la classe Point de coordonnées x et y, on s’y prendrait comme ceci :
Point.new(2, 3)
On utilise la méthode de classe new qui va faire de l’espace en mémoire, et appeler la méthode initialize, qui nous retourne toujours une nouvelle instance. C’est pourquoi on doit toujours définir la méthode initialize en premier dans une classe, car c’est elle qui définit ce que sera l’objet. Analysons maintenant la syntaxe des classes.
1. Le mot-clé class suivi du nom de la classe2. attr_reader permet un accès aux attributs dont les symboles sont écrits à la suite. Ici
on permet donc la lecture des attributs x et y. attr_accessor permet de modifier et lire la valeur, tandis que attr_writer permet uniquement de la modifier. Cela permet donc un accès aux attributs hors de la classe.
3. La méthode initialize avec 2 paramètres : les coordonnées du point.4. L’enregistrement de ces coordonnées dans les attributs. Ici on utilise l’assignation
parallèle : la première variable prendra la valeur du premier objet après le signe =, la 2e avec le 2e.
12
5. Fin de la méthode initialize.6. La méthode d’addition de 2 points, avec p, le paramètre contenant l’autre point.7. Instanciation de la classe Point, autrement dit création d’un nouveau point, avec
comme coordonnées l’addition des coordonnées des 2 points. p.x et p.y étant les valeurs des attributs x et y, permis par attr_reader.
8. Fin de la méthode +.9. La méthode de classe O, qui renvoie le point à l’origine.10. Création d’un nouveau Point de coordonnées (0,0).11. Fin de self.O.12. La méthode to_s, destinée à convertir l’objet en String.13. Ici la chaîne de caractères, de la forme "x,y". Pour rappel, #{} permet l’évaluation de
l’expression, ici les attributs x et y.
13
4. Structure
4.1. Les conditions1
4.1.1. if / unless
Il existe plusieurs types de conditions, la plus simple étant le test binaire oui/non. Le mot clé utilisé est if (si). Le concept de booléen2 est aussi important. Un booléen est un objet qui n’a que 2 valeurs possibles : true or false (vrai ou faux).
if condition
puts 'Condition vraie'
else
puts 'Condition fausse'
end
Ruby évalue condition et nous inscrit si elle est vraie ou fausse. Voici plusieurs exemples de conditions :
[:a, :b, :c].length == 3 #=> true
5*3 < 1 #=> false
true || false #=> true
true && false #=> false
La première vérifie que le nombre d’éléments est égal à 3.La deuxième vérifie si 15 < 1, ce qui est faux.La troisième utilise ||, l’équivalent de OR (OU, ), qui permet de combiner des conditions et renvoie vrai si l’une d’entre elles est vérifiée.La quatrième utilise &&, l’équivalent de AND (ET, ), qui permet de combiner des conditions et renvoie vrai si toutes les conditions sont vérifiées.Il existe 6 opérateurs de comparaison3 :
• == (double égal) : égalité• != : différence• <, <= : strictement plus petit, plus petit ou égal• >, => : strictement plus grand, plus grand ou égal
unless (sauf si, à moins que) est l’équivalent de if not (ou if !condition), c’est dire qu’il exécute les instructions si la condition n’est pas vérifiée.Une syntaxe pratique existe : placer la condition après l’instruction qui pourrait être exécutée :
puts 'tu es majeur' unless age < 18
1 http://www.siteduzero.com/tutoriel-3-12271-les-conditions.html2 Du nom d’un père de la logique, G. Boole3 Le fonctionnement de ces derniers sera expliqué en détail dans la partie Module Comparable.
14
4.1.2. else, elsif
else (sinon, autrement) permet de traiter le cas où la condition n’est pas vérifiée, et elsif condition (sinon si) correspond à else if condition. Ce dernier mot-clé permet une condition alternative.
a, b, c = 1, 2, 3
if a > b
# faux
elsif b > c
# faux
else
puts "a est plus petit que b, et b est plus petit que c" # exécuté
end
4.1.3. case
Lorsqu’il faut gérer un grand nombre de cas semblables, il faut utiliser case (cas). On analyse donc une variable et regarde si elle correspond à chaque condition spécifiée par when. En fait c’est comme si on écrivait une suite de elsif var === cas. On remarque ici un triple égal, car la comparaison est plus large. Ainsi (2..4) === 3 et Integer === 6 sont vrais.
points = 7 # sur 10
puts case points
when 0..2
"NI"
when 3...5 then "I"
when 5..6 then "S"
when 7..8 : "B"
when 9 : "TB"
when 10 : "Excellent!"
else "Erreur..."
end #=> B
La dernière expression évaluée est retournée sur la ligne de case.L’instruction à exécuter, quand la condition est vérifiée (when) , peut être placée soit sur la ligne suivante, soit sur la même ligne que la condition en séparant par then ou :.
4.1.4. Condition ternaire ? :
Pour des simples choix, la condition ternaire est parfois utilisée, au détriment de la lisibilité… Sa syntaxe est condition ? si vrai : si faux.
puts "Vos points sont " + (points >= 5 ? "suffisants" : "insuffisants")
15
4.2. Les boucles1
Une boucle consiste à répéter plusieurs fois un bloc de code.
4.2.1. loop
loop est la plus simple des boucles : elle exécute le bloc en continu. On parle de boucle infinie. Pour en sortir, on utilise break(casser), qui 'casse' la boucle.
4.2.2. while / until
while(tant que) est une boucle qui effectue le bloc tant que la condition est vraie. until fait juste l'opposé: il boucle jusqu'à ce que la condition soit vraie. Le test conditionnel peut aussi être placé en fin de boucle en créant un bloc begin … end, ce qui aura pour effet d’exécuter le bloc au moins une fois.
4.2.3. for in
Il est parfois utile de parcourir des éléments et d'avoir un index, pour chaque élément. « for element in array » boucle en copiant chaque valeur du tableau array dans element.
4.2.4. retry, redo / next, break
Quatre instructions existent pour modifier le comportement d'une boucle. retry recommence depuis le début, redo repasse une fois dans la boucle avec le même élément, next passe au suivant, tandis que break sort de la boucle.
4.3. Itérateurs
Les itérateurs sont un moyen d’accéder aux éléments d’un ensemble un par un. L’exemple type est Array#each { |element| }. Ainsi, ce qui suit imprimera à l’écran l’ensemble des éléments, précédé de son index :
[1, "b", :c].each_with_index { |e, i|
puts "#{i}: #{e}"
}
Résultat :0: 11: b2: c
Array#each_with_index est donc simplement un itérateur qui donne l’élément et l’index !On a aussi des itérateurs sur les nombres entiers :
upto(n), qui va du nombre jusque n. Ex : 2.upto(4) { |i| print i } #=> 234
downto(n), qui descend 1 par 1 jusque n. Ex : 3.downto(2) { |i| print i } #=> 32
times, qui exécute autant de fois le bloc. Ex : 2.times { |i| print i } #=> 01
De même, on aura String#each_line, Hash#each_pair { |key, e| } …Il existe une multitude d’itérateurs détaillés dans la documentation.
1 http://www.siteduzero.com/tutoriel-3-12291-les-boucles.html
16
5. Opérateurs et expressions
5.1. Expressions
En Ruby, les opérateurs sont, pour la plupart, assimilables à des méthodes à syntaxe particulière, dotées d’une priorité semblable à celle en mathématique. Voici la liste des principaux opérateurs dans l’ordre de priorité décroissante :Opérateur Description Méthode invoquée [] []= Accès, assignation à un élément d’un ensemble [](i), []=(a,b)** Puissance **(n)! ~ Négation, complémentaire+@ -@ Unary plus, unary minus1 +@, -@* / % Multiplication, division, modulo2 *(n), /(n), %(n)+ - Addition et soustraction +(n), -(n)<< Ajoute un élément à la fin <<(o)|| && OU, ET logiques
Les opérateurs sont donc comparables à des méthodes, sauf que leur syntaxe est simplifiée (ne nécessite pas de parenthèses ni de ‘.’). Il est à noter que les opérateurs mathématiques (+, -, *, /, %, **) peuvent se noter d’une façon encore plus réduite lorsqu’on modifie l’objet lui-même.
a, b = 2, 3
a = a + b #=> 5 # se simplifie en
a += b #=> 5 # Ajout de b à a et a devient ce résultat
s = "Hello "
s = s + "World!" #=> "Hello World!" # se simplifie en
s += "World!" # ou encore
s << "World!"
5.2. Assignation
L’assignation consiste à copier la valeur à droite dans la variable à gauche. Par exemple x = 3. On peut placer ces assignations où l’on veut, il suffit juste d’ajouter des parenthèses dans certains cas. L’assignation retourne la valeur attribuée. Les assignations peuvent donc aussi être chaînées.
a = 2 + (b = 3) #=> 5 # assignation de 5 à a et de 3 à b
a = b = c = 2 #=> 2 # assignation de 2 à a, b et c
1 Les plus et moins "unaires" sont les signes que l’on place devant l’objet. Par exemple, -4 = 4.-@2 Le modulo est le reste de la division entière. Par exemple, 12%5 = 2
17
5.3. Assignation parallèle
Nous avons déjà vu ce cas de figure : cela permet de modifier la valeur de plusieurs variables sur la même ligne « a, b = 2, 3 ». Mais le mot parallèle indique que ces assignations sont simultanées et nous pouvons donc échanger les valeurs de 2 variables sans problème : a, b = b, a. L’assignation parallèle retourne un tableau des valeurs, et n’est donc qu’un ensemble d’assignations simples. Normalement le nombre de variables à gauche égale le nombre de valeurs à droite. S’il y a plus de valeurs, elles sont ignorées. S’il y a trop de variables, les variables sans valeur correspondante prennent la valeur nil.
Toutefois, une exception existe, car séparer des valeurs par des virgules est un moyen de créer un Array. La réciproque est vraie aussi : enregistrer les valeurs d’un Array dans plusieurs variables séparées. Les commentaires montrent ici un moyen équivalent.
arr = 1, 2, 3 #=> [1, 2, 3] # arr = [1, 2, 3]
a, b, c = arr #=> [1, 2, 3] # a, b, c = arr[0], arr[1], arr[2]
5.4. self
self (soi-même) est une variable fictive dont la valeur dépend du contexte. Voici un résumé des différentes valeurs :
self #=> main # Inutile
class Exemple
def meth
self #=> valeur de l'instance
# permet de retourner celle-ci
end
def self.meth #=> valeur de la classe
# permet de ne pas réécrire le nom
end
end
5.5. gets
gets est une méthode qui permet de demander une ligne texte et la retourne sous forme de String. On entre ainsi le texte dans le terminal, et la ligne se termine dès que l’on presse [Enter]. C’est pourquoi on utilise toujours String#chomp pour supprimer ce [Enter] final.
puts "Quel age avez-vous ?"
age = gets # Renvoie la chaîne + "\n"
age = gets.chomp.to_i # Conversion en entier de la chaîne sans \n
Ainsi si on entre ‘18’, la variable âge vaudra l’entier 18. Le résultat sera le même avec 18.3. Par contre, si on rentre ‘je ne sais pas’, âge vaudra 0.
18
6. Méthodes, Procs et Blocs
6.1. Méthodes
6.1.1. alias
Toutes les méthodes sont redéfinissables en Ruby. Mais pour redéfinir une méthode, il est toujours plus prudent d’utiliser la méthode originale dans le cas qu’on ne gère pas. Il va donc falloir créer une copie. On copie une méthode comme ceci :
alias :puts :afficher # puts est copié dans afficher
afficher 'test' #=> test
Il faut donc mettre le Symbol des noms des 2 méthodes1.
6.1.2. Paramètre optionnel
Le dernier paramètre peut être rendu optionnel, il est alors précédé de ‘*’, et récupéré dans un Array :
def method(a, *b)
return b
end
method(1,2) #=> [2]
method(1,2,3) #=> [2, 3]
6.2. Bloc
Un bloc de code en ruby est délimité par do...end ou {...}. Il peut prendre des arguments, comme une méthode : { |i, e| }. Ce bloc peut être utilisé par yield. Les arguments passés à yield seront passés au bloc, de même que la valeur de retour sera la valeur de retour du bloc. yield est ainsi traduisible par : exécuter le bloc avec les arguments qui suivent. Un exemple simple de bloc est Array#each :
['Bruxelles', 'Paris', 'Berlin'].each { |ville| puts ville }
Résultat :Bruxelles
Paris
Berlin
Ainsi, on passe un bloc qui consiste à afficher chaque (each) élément d’un Array. Dans la méthode Array#each, il y a quelque part un yield(element), qui exécute le bloc de code sur chaque élément.Array.new(n) { |i| } permet de créer un Array, qui passe l’index dans le bloc et ajoute un élément pour chaque index. Voici un tableau des 5 premiers nombre impairs :
Array.new(5) { |i| 2*i+1 } #=> [1, 3, 5, 7, 9]
bloc_given? est une méthode qui permet de savoir si on a donné un bloc à la méthode, en plus des éventuels paramètres.
1 Même si mettre le nom directement fonctionne, ce n’est pas conseillé car on désigne toujours une méthode par
son Symbol correspondant
19
6.3. Proc
Un bloc peut être copié dans une variable, grâce à sa transformation en Proc (procédure), ou à la création d’un objet Proc. Si le dernier argument d’une méthode est précédé d’un « & », le bloc passé sera enregistré sous forme de Proc :def meth(a, &proc)
proc.call(a)endmeth(2) { |i| i*3 } #=> 6meth("a") { |c| c*4 } #=> "aaaa"
Pour plus d’information sur les objets Proc, reportez vous à la documentation (http://ruby-doc.org/core/classes/Proc.html).
20
7. Modules
7.1. Héritage
L’héritage consiste à faire hériter une classe fille des méthodes et attributs d’une classe parente. L’héritage est dit simple en Ruby car une classe ne peut hériter que d’une seule classe parente. Exemple : les petits entiers (Fixnum) héritent des entiers (Integer), qui héritent des valeurs numériques (Numeric), qui héritent de Object, comme tous. On peut connaître la classe parente (dont on hérite) par Class#superclass.
7.class #=> Fixnum
Fixnum.superclass #=> Integer
Integer.superclass #=> Numeric
Numeric.superclass #=> Object
Object.superclass #=> nil # rien n'est au dessus de Object
Il est donc écrit dans la première ligne de la classe Fixnum :
class Fixnum < Integer # Fixnum hérite de Integer
7.2. Modules
Les modules s’apparentent à des classes, et sont en fait une collection de méthodes. La principale différence est que l’on ne peut instancier un Module. Les modules peuvent être inclus dans les classes, et ainsi permettent un autre type d’héritage. Certains modules ont besoin que l’on définisse quelques méthodes dans la classe qui les inclut, afin de pouvoir interagir avec celle-ci. Quelques exemples de modules : Math, Enumerable, Comparable. Analysons-les en détail.
7.2.1. Math
Commençons par un exemple tout simple. Ici le concept de namespace est important. En effet des fonctions comme sin, sqrt pourraient être définies pour une autre utilité. C’est pourquoi on les a groupées dans un module. On les appellera comme ceci :Math.sin, Math.sqrt. Les namespaces ou espaces de noms étant justement ces groupes de méthodes. Ruby les a remplacés par des modules, plus flexibles et pratiques. Les modules peuvent aussi contenir des constantes accessibles par l’opérateur de résolution de portée ::, par exemple Math::PI et Math::E.On aurait pu se dire de placer ces fonctions dans les classes de nombres, mais la syntaxe n’aurait pas été logique : Math.sin(3.14) est plus naturel que 3.14.sin. Si on utilise beaucoup ces opérations, on peut tout simplement inclure le module Math dans le programme :
include Math
cos(PI/3) #=> 0.5
21
7.2.2. Comparable
Le Module Comparable, comme son nom l’indique, permet la comparaison entre les différents objets d’une classe. L’exemple type est celui des nombres. Il faut implémenter la méthode <=>(other) qui renvoie -1, 0 ou 1 suivant que le premier est plus petit, égal ou plus grand que le second. Prenons l’exemple d’une classe Track, dont les instances sont des pistes de musique. On voudrait comparer leur longueur.
class Track
include Comparable
def initialize(file, length)
@path, @length = file, length
end
def <=>(other)
@length <=> other.length
end
end
Nous avons maintenant accès à toutes les méthodes de Comparable : <,<=,==,>=,>,between?
7.2.3. Enumerable
Le Module Enumerable permet de traverser un certain nombre d’objets contenus dans un objet. L’exemple type est celui des Array (tableaux). Il permet d’itérer entre les différents objets contenus dans celui-ci. Il faut implémenter each { |element| block } qui va permettre de faire une action avec chaque élément. L’instruction qui permet d’utiliser le bloc { block } avec un paramètre |element| est yield( element ). Voyons pour cela le cœur même de Array. Le code source est en C (pour des raisons de rapidité), mais je l’ai retranscrit en Ruby.
class Array
def each
for i in (0...length)
yield self[i]
end
self
end
end
J’utilise self[i] pour obtenir une valeur du tableau, et length pour le nombre d’éléments. Nous avons dès lors une multitude de méthodes qui itèrent notre ensemble d’objets. Parmi les plus utiles, on trouve : each { |e| block }, map { |e| block }, inject(init) { |memo, obj| block }.
22
8. Contrôle
8.1. Les exceptions
De temps à autre, votre programme provoque une erreur. C’est bien normal, il est assez rare d’écrire du premier coup un programme exempt de toute erreur. En Ruby, les erreurs sont des sous-classes de la classe Exception. Le nom veut bien dire qu’une erreur est rarement fatale, et peut souvent être résolue sur le champ par quelques précautions. Une des exceptions les plus connues est ZeroDivisionError, qui se déclenche lors de la division par zéro. Voyons l’exemple d’ouverture d’un fichier.
begin
text = File.read('test.txt') # test.txt n'existe pas => Erreur
# ...
rescue
puts "Le fichier n'est pas lisible. Erreur:"
puts $! # $! est la dernière erreur provoquée
ensure
puts "Ceci sera toujours exécuté"
end
Si une exception se déclenche, on passe directement dans la partie rescue, et la partie ensure sera toujours effectuée, qu’il y ait erreur ou non.
8.2. ObjectSpace
Il existe en Ruby un moyen de contrôler ce qui est dans la mémoire à tout moment, c’est l’itérateur ObjectSpace.each_object { |object| }. Voici un exemple simple pour compter le nombre d’objets de chaque classe dont le nombre est plus grand que 25.
objects = {}
ObjectSpace.each_object { |o|
c = o.class.to_s
objects[c] = 0 unless objects.has_key? c
objects[c] += 1
}
objects.each { |c, n| puts "#{c}: #{n}" unless n < 25 }
Résultat :Range: 50Regexp: 192Array: 124Hash: 40Proc: 143Module: 62Class: 423String: 7214
23
On voit ici une énorme majorité de String, qui est en fait pour une bonne partie les messages d’erreurs et de traitement. 423 classes aussi, plus les modules … il est clair que vous n’êtes pas près d’avoir tout vu…
24
9. Exemple 1 : Les Polynômes
Voici le premier exemple pratique. Je l’ai choisi pour sa simplicité et sa facilité. Pour rappel, un polynôme est un ensemble de monômes et se note sous la forme générale :
1 3 21 3 2 1 0( ) ...n n
n nP x a x a x a x a x a x a−−= + + + + +
Il faut tout d’abord établir la structure des données. On a un ensemble de monômes, ou une collection de coefficients avec une variable définie pour tout le polynôme… Notre classe Polynôme aura donc ces membres :
• Un Array de nombres (Numeric), que l’on appellera @a en mémoire de la lettre utilisée pour les coefficients.
• Un nombre (Integer) @degre pour le degré du polynôme, fort utile, et donc il vaut mieux ne le calculer qu’une fois.
• Un String contenant le nom de la variable, par défaut 'x', que l’on nommera @var.Mais il serait plus agréable de pouvoir créer un polynôme en utilisant directement un nombre d’arguments correspondants au nombre de coefficients. Par exemple, pour créer x² + 2x + 4, on ferait : Polynom.new(1,2,4). Or ici le premier argument est 1, et il correspond au degré 2. On va devoir inverser l’ordre des arguments pour ainsi obtenir [4, 2, 1], les indices du tableau étant alors les exposants de la variable. Nous pouvons dès lors définir le constructeur.
class Polynome
def initialize(*args)
@a = args.reverse # Les arguments dans le sens inverse
@degre = @a.length - 1 # Le degré est le nombre de termes-1
@var = 'x' # Par défaut, la variable est x
end
end
p Polynome.new(1,2,4)
#=> #<Polynome:0x2e8c798 @coef=[4, 2, 1], @var="x", @degre=3>
On obtient bien ce que l’on voulait, sauf que la sortie n’est pas très jolie. Il faut donc redéfinir la méthode #to_s et #inspect. Et c’est là que ça se complique un peu, à cause de la syntaxe particulière des maths. Essayons simplement via Integer#down_to, une méthode qui permet d’itérer d’une valeur maximale (le degré) à une minimale (degré 0).
class Polynome
def inspect
str = ''
@degre.downto(0) { |i|
signe = (@a[i] >= 0) ? '+' : '-'
str += " #{signe} #{@a[i]}x^#{i}"
}
str
end
alias :to_s :inspect # Copions inspect dans to_s
end
25
p Polynome.new(1,2,4)
#=> + 1x^2 + 2x^1 + 4x^0
C’est mieux, mais ce n’est pas encore ça. Il faudrait créer une classe de monômes. Voir le fichier « Scripts/Polynome/monome.rb ». L’affichage est maintenant correct. Vous pouvez essayer dans IRB en tapant dans la console (cliquez sur l’icône de la console dans Scripts/Polynome) « irb », puis « require 'polynome.rb' » et enfin tester.
26
10. Exemple 2 : Les Points
Cet exemple montre quelques nouveautés et détails. Les concepts de base ne sont plus expliqués. Ceci est un aperçu du fichier "Scripts\point.rb" sur le CD.
class Point
attr_accessor :x, :y
def initialize(x, y)
@x, @y = x, y
end
def self.O # Point.O
Point.new(0, 0)
end
O = Point.new(0, 0) # Point::O
def +(o)
case o
when Point
Point.new(@x+o.x, @y+o.y)
when Numeric
Point.new(@x+o, @y+o)
end
end
def -(o)
self + (-o)
end
def *(n)
Point.new(@x*n, @y*n) if n.is_a? Numeric
end
def /(n)
Point.new(@x/n.to_f, @y/n.to_f) if n.is_a? Numeric
end
def coerce(o)
[self, o]
end
def -@
Point.new(-@x, -@y)
end
def med(p) # Point
27
(self+p)/2.0
end
def length(p) # Point
Math.sqrt((p.x - self.x)**2 + (p.y - self.y)**2)
end
def inspect
@x = @x.to_i if @x.to_i == @x
@y = @y.to_i if @y.to_i == @y
"#{@x},#{@y}"
end
alias :to_s :inspect
end
Dans la méthode +, les actions sont différenciées selon la classe de l’objet. Un nombre sera additionné aux coordonnées. Comme dans la différence et la multiplication.La méthode -@, qui change le signe des coordonnées, et est très utile pour la différence qui n’est plus alors qu’un cas particulier de l’addition.La méthode coerce est probablement la plus intéressante. Elle permet de profiter de la commutativité automatique. Si elle n’était pas définie, Point.new(2,3)*2 fonctionnerait mais pas 2*Point.new(2,3).Cette dernière instruction est le raccourci de 2.* ( Point.new(2,3) ). Or Integer#*(Point) n’est pas défini. Dans les opérations sur les entiers, il est mis qu’en cas de non réussite par les moyens habituels, il y a un appel de la méthode coerce de l’objet, qui doit retourner un Array où le premier élément sera l’objet sur lequel on applique la méthode, et le second le paramètre. Ainsi, lors de 2*Point.new(2,3), l’expression sera transformée en Point.new(2,3)*2, par coerce, qui ici ne fait qu’inverser l’ordre. Le problème est que cela est aussi valable pour +, - et /. Mais il n’y aurait aucun sens à écrire 2 - Point, même si cela fonctionne. Un autre moyen aurait été de modifier, dans les entiers eux-mêmes, la multiplication1, mais cela est laborieux et pas très propre.med calcule simplement le point au milieu du segment entre 2 points et length la distance à un point.Enfin, nous avons 2 lignes dans inspect qui vont convertir les Float en Integer si la valeur est la même. Sinon Point.new(2,4)/2 donnerait « 1.0,2.0 » et pas « 1,2 ».
1 A noter que la multiplication n’est pas définie dans Integer, mais dans ses 2 sous-classes, Fixnum et Bignum. Il faudrait donc faire la modification 2 fois.
28
11. Exemple 3 : Utilisation d’ id3lib
id3lib est l’extension qui permet de gérer les id3tag, qui sont des informations (auteur, titre, …) contenues dans les fichiers de musique (mp3, aac, ogg, …). Les id3tag ne sont pas toujours présents, ou parfois incomplets. Lorsque que vous avez un grand nombre de fichiers de musique dans le même dossier, il n’est ni harmonieux ni pratique que les noms de ces fichiers soient si hétérogènes (ex : « 01 - ZITA SWOON - Hey You Whatshadoing.mp3 » et « Eric Carmen - Hungry Eyes.mp3 »). Le but de ce script sera donc de renommer le fichier avec l’aide des informations contenues dans les id3tag. Nous avons besoin pour cela du gem (extension de Ruby) « id3lib ». Pour l’installer il suffit de taper dans un terminal :
gem install id3lib-ruby
Il faut choisir l’option 2 : id3lib-ruby 0.5.0 (mswin32).Voici le script (aussi dans Scripts/id3tag.rb).
1 require 'rubygems' # Utiliser les gems de Ruby
2 require 'id3lib' # Inclure id3lib
3
4 Dir['*.mp3'].each { |path|
5 tag = ID3Lib::Tag.new path
6 begin
7 artist, title = tag.artist, tag.title
8 raise "no artist in" if( artist.nil? || artist == '' )
9 raise "no title in" if( title.nil? || title == '' )
10 name = artist+' - '+title+'.mp3'
11 name.tr!('\\*?"<>|', '') # caractères interdits
12 name.tr!('/:', ' ') # dans les noms de fichiers
13 File.rename(path, name) unless name == File.basename(path)
14 p name unless name == path
15 rescue
16 puts $!
17 puts "\t#{path}"
18 end
19 }
En ligne 4, j’utilise Dir[String] qui permet de sélectionner des fichiers. Ici je sélectionne tous les fichiers .mp3 dans le dossier courant. Dir['**/*.mp3'] permettrait de sélectionner en plus tous ceux dans les sous-dossiers. Cette méthode renvoie un Array des chemins de fichier (paths).Dans les lignes 8-9, je vérifie si l’artiste et le titre de la chanson sont bien présents, sinon je soulève une exception, qui m’enverra dans le bloc rescue, et m’affichera l’erreur et le chemin de fichier.Je vous laisse regarder dans la documentation les méthodes que vous ne connaissez pas encore (String#tr!, File.rename, File.basename), et la documentation d’ id3lib : http://id3lib-ruby.rubyforge.org/doc/index.html
29
12. Conclusion
La conclusion de ce TPE est singulière. En effet je ne peux parler ni de problématiques, ni de questions au sens habituel. Néanmoins, je pense que cadrer l’intérêt de Ruby est une conclusion intéressante.
Ruby est un langage de programmation des plus modernes. C’est un langage de haut niveau et il n’est donc pas axé sur la rapidité, mais sur la flexibilité, la simplicité et la production1. Son créateur s’est concentré sur le facteur humain2 :
“ [...] Les ordinateurs ne s’en préoccupent pas. Nous, les humains, nous nous préoccupons de l'effort que nous faisons. La plupart des gens, en particulier les ingénieurs informaticiens, pensent à leurs machines. Ils pensent que, ‘En faisant cela, la machine sera plus rapide. En faisant cela, la machine fonctionnera plus efficacement. De cette façon, la machine fera …’. Ils se concentrent sur les machines. Mais en fait, nous devons nous concentrer sur l'homme, sur la façon dont les humains programment ou la façon de l’appliquer sur les machines. Nous sommes les maîtres. Elles sont les esclaves. ”3
Matz a déclaré que son but était « de rendre Ruby naturel, pas simple ».4 En d’autres mots, il a créé un langage dont certaines bases sont très complexes, mais dont l’utilisation est aisée. Le programmateur Ruby peut se consacrer surtout à la conception de son programme sans devoir en permanence penser à respecter les normes du langage. La plupart des méthodes peuvent s’enchaîner de gauche à droite, contrairement à bon nombre d’autres langages. Certains disent qu’il respecte le « principe de la moindre surprise » (principle of least surprise). En fait, une fois que le programmateur suit le raisonnement de Ruby, il ne rencontre plus que rarement des surprises inattendues.
Tout est donc fait pour que le langage soit élégant et simple. Et c’est ça la beauté de Ruby, c’est sa flexibilité qui le rend naturel, facile, voire merveilleux aux yeux de l’homme !
N’hésitez en aucun cas à me contacter ([email protected]), cela me ferait le plus grand plaisir de répondre à vos questions !
1 http://www.ruby-lang.org/fr/2 http://www.artima.com/intv/ruby4.html3 “[...] The computers don't care. We humans care about the effort we pay. Often people, especially computer engineers, focus on the machines. They think, ‘By doing this, the machine will run faster. By doing this, the machine will run more effectively. By doing this, the machine will something something something.’ They are focusing on machines. But in fact we need to focus on humans, on how humans care about doing programming or operating the application of the machines. We are the masters. They are the slaves.” (même source)4 http://www.ruby-lang.org/fr/about/
30
13. Sources
Sites Internet : • http://www.ruby-lang.org : Site officiel• http://fr.wikipedia.org/wiki/Ruby : Page française de Ruby sur Wikipédia• http://www.siteduzero.com : Site de tutoriaux français variés• http://www.siteduzero.com/tutoriel-2-207-ruby.html : Les tutoriaux sur Ruby
Livres : THOMAS, D. , Programming Ruby, The Pragmatic Programmers’ Guide, The Pragmatic Programmers, Second Edition.
Version 1 disponible sur http://ruby-doc.org/docs/ProgrammingRuby/.FLANAGAN D., MATSUMOTO Y., The Ruby Programming Language, O’REILLY, 2008.MATSUMOTO Y., Ruby in a Nutshell, O’REILLY, 2001.
Personnes : J’aimerais me citer moi-même, car la plus grande partie du texte est tirée de mes
connaissances, certes venant de différentes sources, mais aussi de ma pratique de la programmation depuis quelques années et de mon intérêt pour cela.
31
14. Glossaire
MotifChaîne de caractères (String) constituant une RegExp.
O.S.Operating System, système d’exploitation.
Racine d’un disque“Dossier” contenant tous les autres. Par example: C:\.
CaractèreTout symbole pouvant être tapé au clavier. Exemples: a, 6, è, }, $, …
AssignationAction d’attribuer une valeur à une variable.
32
Annexes
Table des annexes
I.Terminal ............................................................................................................................................................... II
II.Expressions régulières ......................................................................................................................................IIIII.I.Exemple introductif...................................................................................................................................... IIIII.II.Les métacaractères...................................................................................................................................... IIIII.III.Exemples....................................................................................................................................................III
III.Mise en page .................................................................................................................................................... IV
IV.Tableau des variables d’environnement ..........................................................................................................V
V.Hiérarchie des principales classes ....................................................................................................................VI
I
I. Terminal
Il existe un très bon tutorial sur le terminal de Windows à cette adresse : http://www.siteduzero.com/tutoriel-3-9064-les-bases-du-ms-dos.htmlJ’ai néanmoins fait un résumé des points nécessaires ici.
« Terminal » est le terme générique que j’ai choisi pour désigner la console, un shell, ou encore une ligne de commande (command prompt). La manière d’ouvrir un terminal diffère selon les O.S.Sous Windows, il faut cliquer sur Démarrer->exécuter (ou appuyer sur la touche [Windows] + R) et entrer cmd ou command et valider (OK). Un autre moyen est de copier le raccourci vers la console, qui est gravé sur ce CD.
Un terminal démarre toujours à un endroit précis, un chemin de fichier (path). En général, c’est le dossier de l’utilisateur courant. Les séparateurs de fichiers/dossiers des path sous Windows sont les anti-slashs (\) : C:\dossier\fichier.extension.
Une fois le terminal ouvert, vous voyez du texte qui s’affiche à l’écran. Vous pouvez dès lors entrer une commande. Je vais vous présenter quelques commandes qui nous serviront. Tout d’abord, on entre une commande en tapant au clavier et les caractères ainsi tapés s’affichent dans le terminal et on valide la commande par [Enter]. Les noms de fichiers ou dossiers utilisés en arguments (caractères après le mot de commande, entre [] dans mes explications), peuvent être auto-complétés en utilisant la touche [Tab].
• cd [dossier] : Change Directory, change de dossier. Il faut remplacer [dossier] par le dossier où l’on veut aller. Par exemple, "cd ruby" va changer le dossier de départ si un dossier ruby existe dans le dossier actuel. cd .. permet de remonter d’un dossier (d’aller au dossier parent) si toutefois on n’est pas à la racine du lecteur. Exemple : si je suis dans "C:\Documents And Settings\User" et je dois aller dans le dossier de mon programme F:\Ruby, je dois premièrement changer de disque avec F: et ensuite entrer cd Ruby.
• ruby [prog.rb] : Permet de lancer le programme prog.rb avec l’interpréteur Ruby dans le terminal. Il faut par contre que le dossier courrant de la console soit celui du programme (voir cd ci-dessus).
II
II. Expressions régulières 1
Les RegExp, ou expressions régulières sont un moyen puissant de modifier des chaînes de caractères. Plongeons directement dans le sujet pour comprendre par l’exemple.
II.I. Exemple introductif
Nous cherchons le mot ‘ruby’ dans un texte.
"Le ruby est ..." =~ /ruby/ #=> 3
Le code nous renvoie la position de la première lettre du mot ‘ruby’ (0:L,1:e,2: ,3:r).Mais on obtient bien plus que la position, on a aussi le mot cherché avec $&, le texte qui suit avec $’, ...Les RegExp ont une syntaxe assez complexe, et certains livres ont été dédiés à ces expressions. C’est pourquoi nous n’étudierons que les exemples assez simples.
II.II. Les métacaractères
Les métacaractères sont des caractères qui ont une fonction spéciale dans le motif. Voici leur liste et leur signification :
Description Motif Exemples^ La chaîne doit commencer à cet endroit /^un/ un, une, unique$ La chaîne doit finir à cet endroit /e$/ fille, homme, nature. (point) N’importe quel caractère sauf \n /ch.t/ chat, ch%t, bachelier{min,max} nombre de répétitions du motif précédent
Si max est omis, il n’y pas de maximum/a{2,3}/ aa, aaah
? optionnel = {0,1} /to?i/ toi, tir* répétition = {0,} /c.*a/ ca, cela, char+ un ou plusieurs = {1,} /a+h/ ah, aah, aaaaah[] Classe de caractères /ch[aeiou] / chat, cher, choux[^] Classe de caractères rejetés /c[^a]/ cet- (entre [ et ]) intervalle de lettres ou chiffres /a[a-p][0-2]/ ac0, ao2| Ou, permet l’un ou l’autre /ca|tu/ ca, tu
II.III. Exemples
Prenons la syntaxe des méthodes comme exemple. Si vous vous rappelez, les caractères a-zA-Z, 0-9 et _ sont acceptés, mais le nom de la méthode doit toujours commencer par une lettre.La voici : /^[a-zA-Z][a-zA-Z0-9_]*$/Premièrement, on ne veut que le nom de la méthode, donc le nom doit commencer et terminer la chaîne. Donc on inscrit ^ au début, et $ à la fin : /^$/Deuxièmement, le premier caractère doit être une lettre : /^[a-zA-Z]…$/Troisièmement, les caractères acceptés suivent et peuvent être au nombre de 0 (dans ce cas le nom ne comporte qu’une lettre) ou plus, d’où le quantificateur *.
1 http://www.siteduzero.com/tutoriel-3-14668-un-site-dynamique-avec-php.html
III
III. Mise en page
La mise en page de ce TPE est quelque peu spéciale. Je n’ai volontairement pas ajouté d’alinéas partout, contrairement aux conventions, car cela pose de nombreux problèmes. Ce TPE n’est pas littéraire - étant donné son sujet – et les paragraphes sont nombreux et courts. De même, le grand nombre de pages est dû à l’insertion d’une grande partie de code, que j’ai essayé de réduire au minimum.
IV
IV. Tableau des variables d’environnement
Voici un tableau récapitulatif des variables d’environnement les plus utiles de Ruby.Variable Type Description Utilité$0 String Nom du script exécuté Test si c’est le script exécuté :
if $0 == __FILE__$: Array Array des dossiers où seront cherchés les
fichiers demandés par requireAjouter un dossier pour inclure :$: << 'myclassdir'
$! Exception Dernière exception (erreur) puts $! # Affiche l’erreur
$> IO Sortie standard (défaut : terminal) Permet de rediriger la sortie :$> = File.new('out.txt', 'w')
RegExp$& String La chaîne testée$` String La chaîne précédant la partie recherchée$' String La chaîne suivant la partie recherchée$1~$9 String Contenu de la nème parenthèse capturante.
V
V. Hiérarchie des principales classes
Voici la liste des principales classes initiales dans Ruby.Object Module Class
IO FileNumeric Float
Integer FixnumBignum
StringSymbolArrayHashRangeRegexpTimeDate DateTimeProcMethodStructDir
Exception StandardErrorScriptError SyntaxError... ...
VI
