Premiers Pas Avec Ruby

Premiers pas avec Ruby

par Pierre-Baptiste Naigeon (Tutos, tests et articles web)

Date de publication : 26 Mars 2007

Dernire mise jour : 26 Mars 2007

Ruby est un langage interprt entirement orient objet, et multi plate-forme.

Outre le fait d'tre trs intuitif (vous verrez pourquoi dans la suite de ce cours),Ruby peut servir de langage de script au mme titre que PERL ou d'autres,mais son essor rcent est surtout d l'apparition de Ruby on Rails, unframework web extrmement puissant bas sur Ruby.

Nous allons voir ici les bases de ce langage, ses atouts, etc.

Premiers pas avec Ruby par Pierre-Baptiste Naigeon (Tutos, tests et articles web)

- 2 -Les sources prsents sur cette pages sont libres de droits, et vous pouvez les utiliser votre convenance. Par contre la page de prsentation deces sources constitue une oeuvre intellectuelle protge par les droits d'auteurs. Copyright 2006 - Pierre-Baptiste Naigeon. Aucune reproduction,mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse del'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.

http://pbnaigeon.developpez.com/tutoriel/ruby/premiers-pas-avec-ruby/

I - Installation et concepts de baseII - Premiers pas

II-A - Manipulation de variables simplesII-B - TableauxII-C - Hash / tableaux associatifsII-D - Manipulation de chanes, de tableaux et de hashII-E - Conventions de nommageII-F - Expressions rgulires

III - Cration de notre premire classeIII-A - Dfinition de la classe et de ses mthodes, variables d'instanceIII-B - Constructeur : mthode initializeIII-C - Variable de classeIII-D - Simplification de la classe grce RubyIII-E - Et l'hritage alors ?III-F - Redfinir une mthode

IV - Et les modules, qu'est-ce que c'est ?V - Les structures de contrle

IV-A - Oprateurs de comparaisonIV-B - if ... else ... endIV-C - case ... endIV-D - unless ... endIV-E - while ... endIV-F - until ... endIV-G - for ... endIV-H - each { ... } et autres itrateursIV-I - Sortie de boucles

VI - ProcduresVII - Gestion d'erreurs

VII-A - begin ... rescue ... endVII-B - ... retry ...VII-C - ... raise ...VII-D - .. ensure ...

VIII - Manipulation de fichiersVIII-A - Cration de fichiers et de dossiersVIII-B - Afficher le contenu d'un fichier ligne par ligne avec le numro de ligneVIII-C - Ecrire dans un fichierVIII-D - Renommer un fichierVIII-E - Lister le contenu d'un rpertoire et de ses sous rpertoires tri par ordre alphabtique

IX - Bases de donnes - MySQLIX-A - Installer MySQL pour RubyIX-B - Exemple d'utilisation

X - Conclusion et remerciements




I - Installation et concepts de base

Voyons comment installer Ruby sous Windows.

Rien de trs compliqu, il vous suffit de vous rendre sur la page de Ruby, puis de cliquer sur "Tlchargements", etde tlcharger le One-Click Installer pour Windows. Il ne vous reste plus qu' choisir votre rpertoire d'installation,et valider en attendant la fin de la procdure d'installation.

Ruby est livr par dfaut avec deux diteurs : SciTe et FreeRIDE.

Pour lancer FreeRIDE (intgralement crit en Ruby), rendez-vous dans le rpertoire d'installation de Ruby, puis dansle rpertoire "freeride", et excutez "run.bat".

Je prfre SciTe, mais cela ne dpend que de considrations personnelles. Pour le lancer, rendez-vous dans lerpertoire d'installation de Ruby, puis dans le rpertoire "scite", et excutez "SciTE.exe".

En Ruby, tout est objet. Absolument tout. Un entier, une chane de caractres, et mme les classes, aussi tonnantque cela puisse paratre.




II - Premiers pas

Nous allons apprendre par l'exprience. Pour cela, nous allons utiliser irb (interactive Ruby).

En utilisant irb, nous allons pouvoir tester la syntaxe de base de Ruby et en visualiser directement le rsultat, sansavoir crer un fichier contenant notre code (un .rb) et le modifier chaque fois. Il vous suffit de lancer une fentreDOS (dmarrer -> excuter -> cmd), puis de taper "irb" dans l'invite de commande, et de valider.

II-A - Manipulation de variables simples

L'invite de commande s'est modifie. Vous pouvez dsormais taper directement vos commandes. Essayez de taperles lignes suivantes :

a = 2

b = 3

puts "a + b vaut " + (a+b).to_s

Voici ce que vous devriez obtenir l'cran :

irb(main):001:0> a = 2=> 2irb(main):002:0> b = 3=> 3irb(main):003:0> puts "a + b vaut " + (a+b).to_sa + b vaut 5=> nil

Beaucoup de choses dans ce simple exemple. Nous venons de crer deux variables, a et b, et de leur affecter desvaleurs. Ensuite, nous avons dcid d'afficher leur somme l'aide de la mthode puts. Nous affichons donc unechane (la partie entre guillemets), que nous concatnons une autre chane l'aide de l'oprateur +.

Cette deuxime chane est en fait le rsultat de la somme de nos deux variables (encore cette fois l'aide del'oprateur +, qui n'a donc pas la mme fonction suivant le type avec lequel il est utilis), que nous convertissons enchane l'aide de la mthode to_s (pour rendre possible la concatnation, il nous faut deux types identiques).

Vous remarquerez que nulle part nous n'avons dfini le type de a ou de b. Ruby se dbrouille comme un grand : c'estle duck typing (a ressemble un canard, a se comporte comme un canard, donc c'est un canard).

Les oprateurs sur les nombres restent trs classiques : + pour l'addition, - pour la soustraction, * pour la multiplication,et / pour la division.

A noter tout de mme ** pour la puissance : a**n signifie a la puissance n. Ici, n peut tre un rel, donc pour obtenirracine de 2, il est tout fait possible de faire 2**0.5.

Reste la fonction modulo : %, qui renvoie le reste de la division entire.

Ici, nous avons crit "a+b". Or, en Ruby, tout tant objet, les oprateurs ne sont que desmthodes.




Nous aurions donc pu crire "a.+(b)" : l'appel la mthode + de l'objet a avec en paramtrel'objet b.

Peu pratique crire, vous en conviendrez, mieux vaut utiliser la premire notation. Rubyest bourr de ces sucres syntaxiques qui nous facilitent la vie.

Dans la mme veine que to_s, voici quelques fonctions utiles de manipulation de chane :

to_i : convertit une chane en un entier, ou retourne la partie entire d'un rel to_f : idem, mais retourne un rel length : retourne la longueur d'une chane ou la longueur d'un tableau upcase : convertit une chane en majuscules downcase : convertit une chane en minuscules

swapcase : intervertit les majuscules et les minuscules dans une chane capitalize : met en majuscule le premier caractre de la chane reverse : inverse la chane ou les lments d'un tableau

Jouons encore un peu, et dcouvrons les chanes.

Une chane peut tre dfinie soit entre apostrophes, soit entre guillemets. Une chane dfinie entre apostrophesne prendra pas en compte les caractres spciaux (\n par exemple), et n'valuera pas non plus les expressionsentoures par #{...} (que nous verrons un peu plus tard, irb ne le comprend pas).

Crons donc une chane simple :

c = 'cou'

puts c * 2

Et observons la sortie :

irb(main):004:0> c = 'cou'=> "cou"

irb(main):005:0> puts c * 2=> "coucou"

Merveilleux, la multiplication rpte notre chane !

Voyons maintenant comment demander l'utilisateur une saisie clavier :

saisie = gets puts saisie.chomp

saisie2 = gets.chomp

irb(main):006:0> saisie = getscoucou




=> "coucou\n"irb(main):007:0> saisie.chomp=> "coucou"

irb(main):008:0> saisie2 = gets.chomptralala=> "tralala"

Ici, gets permet de demander l'utilisateur de saisir une valeur. En observant bien, on se rend compte que la frappesur la touche Entre est incluse dans la chane (le \n). Pour l'enlever, rien de plus simple, il suffit d'utiliser la mthodechomp, qui renvoie notre chane sans le caractre de retour la ligne.

Lorsque vous souhaitez effectuer le remplacement de variables dans une chane en Ruby,il faudra utiliser la syntaxe suivante (notez bien la prsence de guillemets pour la chaneo se produit la substitution) :

nom = 'Pierre-Baptiste'puts "Bonjour #{nom}

Et voici la sortie :

Bonjour Pierre-Baptiste

Rappel : irb ne le comprend pas.

II-B - Tableaux

Nous allons maintenant crer un tableau :

mon_tableau = ["a", 12, "b"]

irb(main):001:0> mon_tableau = ["a", 12, "b"]=> ["a", 12, "b"]

Pour accder aux diffrents lments de notre tableau, il suffit de faire suivre le nom de notre variable de crochets,avec l'indice dsir entre les crochets. Le premier indice du tableau est 0 :

puts mon_tableau[1] mon_tableau[1] = 42 puts mon_tableau[1]

irb(main):002:0> puts mon_tableau[1]12=> nilirb(main):003:0> mon_tableau[1] = 42=> 42irb(main):004:0> puts mon_tableau[1]42=> nil

Il existe de nombreuses autres mthodes qui s'appliquent aux tableaux : push, pop, last, etc.




irb(main):005:0> tablo = ['a', 'z', 'e', 'r', 't']=> ["a", "z", "e", "r", "t"]irb(main):006:0> tablo.push('y', 'u')=> ["a", "z", "e", "r", "t", "y", "u"]irb(main):007:0> tablo.pop=> "u"

irb(main):008:0> tablo=> ["a", "z", "e", "r", "t", "y"]irb(main):009:0> tablo.last=> "y"irb(main):010:0> tablo=> ["a", "z", "e", "r", "t", "y"]

Juste une petite mthode fort sympathique pour en finir avec les tableaux : la mthode "sort". Faites juste un"mon_tableau.sort", et vous verrez alors votre tableau tri :)

II-C - Hash / tableaux associatifs

Ruby gre galement les tableaux associatifs. Il faut juste noter qu'en Ruby, ils sont appels "hash".

mon_hash = {:nom => "Naigeon", :prenom => "PB"}

irb(main):001:0> mon_hash = {:nom => "Naigeon", :prenom => "PB"}=> {:nom => "Naigeon", :prenom => "PB"}

Accder aux lments n'est gure plus compliqu :

puts mon_hash[:nom] puts mon_hash[:prenom] mon_hash[:prenom] = "Pierre-Baptiste" puts mon_hash[:prenom]

irb(main):002:0> puts mon_hash[:nom]Naigeon=> nilirb(main):003:0> puts mon_hash[:prenom]PB=> nilirb(main):004:0> mon_hash[:prenom] = "Pierre-Baptiste"=>"Pierre-Baptiste"irb(main):005:0> puts mon_hash[:prenom]Pierre-Baptiste=> nil

II-D - Manipulation de chanes, de tableaux et de hash

Il est possible d'accder aux diffrentes parties de la chane comme suit :

irb(main):001:0> ma_var = 'azerty'=> "azerty"irb(main):002:0> ma_var[0]=> 97




irb(main):003:0> ma_var[0..0]=> "a"

irb(main):004:0> ma_var[0..3]=> "azer"

irb(main):005:0> ma_var[0,4]=> "azer"

irb(main):006:0> ma_var[-2,2]=> "ty"

Dans le premier cas, nous obtenons le code ASCII de la premire lettre (l'indice 0).

Ensuite, nous lui demandons d'afficher les lettres comprises entre l'indice 0 et l'indice 0 (les bornes sont inclues). Iln'y en a qu'une, il nous renvoie donc "a".

Puis nous lui demandons donc d'afficher les lettres comprises entre l'indice 0 et l'indice 3 (quatre lettres donc). Ilnous retourne "azer".

Nous lui demandons ensuite de nous afficher partir de l'indice 0 une chane de longueur 4. Il nous retourne doncencore "azer".

Pour finir, nous lui passons un indice ngatif. Les indices ngatifs partent de la fin du tableau (et commencent 1,eux, puisqu'il est dur de diffrencier 0 et -0). Nous lui demandons donc d'afficher partir du deuxime caractre avantla fin une chane de longueur 2 (les deux derniers caractres quoi !).

Il est possible de procder de mme avec les tableaux :

irb(main):007:0> mon_tabl = ['q', 'w', 'e', 'r', 't', 'y']=> ["q", "w", "e", "r", "t", "y"]irb(main):008:0> mon_tabl[0]=> "q"irb(main):009:0> mon_tabl[0..0]=> ["q"]irb(main):010:0> mon_tabl[0..3]=> ["q", "w", "e", "r"]irb(main):011:0> mon_tabl[0,4]=> ["q", "w", "e", "r"]irb(main):012:0> mon_tabl[-2,2]=> ["t", "y"]

Cela fonctionne exactement comme prcdemment. Faites juste attention au fait que mon_tabl[0] retourne unechane (dans le cas prsent), alors que mon_tabl[0..0] retourne cette mme chane, mais dans un tableau !

Encore deux petites fonctions extrmement utiles avant de conclure cette section : split et join (quivalents de explodeet implode en PHP).

irb(main):010:0> ma_date = '18/02/1981'=> "18/02/1981"irb(main):011:0> mon_tableau = ma_date.split('/')=> ["18", "02", "1981"]irb(main):012:0> ma_date2 = mon_tableau.join('-')=> "18-02-1981"

Vous pouvez bien entendu spcifier le sparateur de votre choix.




Split vous permet donc de dcouper une chane dans un tableau en fonction d'un sparateur donn, et join vouspermet de regrouper les lments d'un tableau dans une chane, toujours avec un sparateur.

A vous maintenant la manipulation de chanes :)

II-E - Conventions de nommage

Variables et mthodes

nom_var

nom_methode

nom_methode? (une mthode qui renvoie true ou false : is_a?(Fixnum)) nom_methode! (une mthode "destructrice", souvent qui modifie la variable : sort!) @nom_var_instance @@nom_var_classe $nom_var_globale (Attention, peut aussi s'crire en majuscules : $NOM_VARIABLE_GLOBALE)

Classes

NomClasse

Constantes

NOMCONSTANTE ou NomConstante

II-F - Expressions rgulires

Ruby est tout fait de taille jouer avec les expressions rgulires. En revanche, moi, je suis loin d'tre de taille jouer avec elles, c'est pourquoi vous ne disposerez ici que d'un petit exemple, vous de faire la suite ;)

chaine = 'la couleur #FF024D est-elle une couleur HTML ?'

test = (chaine =~ /#[0-9A-Fa-f]{6}/)

if (test) puts "la chaine #{chaine[test,7]} est un code couleur HTML valide !"else puts "Pas de code couleur HTML valide dans la chaine"end

Nous nous contentons simplement de parcourir notre chane la recherche du motif, et nous renvoyons sa positionsi le motif est trouv.

Notez simplement l'oprateur "=~". C'est l'oprateur rserv l'valuation d'expressions rgulires. Il retourne laposition du premier caractre qui correspond dans la chane, nil si rien n'est trouv.




III - Cration de notre premire classe

III-A - Dfinition de la classe et de ses mthodes, variables d'instance

Nous allons nous atteler la cration de classes. Dsormais, nous coderons directement dans un fichier. Crez doncun nouveau fichier nomm par exemple animaux.rb.

Nous allons y placer le code suivant :

class Animalend

cochon = Animal.new

Nous avons donc ici une dfinition de la classe "Animal", ainsi que la cration d'une instance de cette classe, nomme"cochon".

Une classe se dfinit en utilisant le mot-cl "class", suivi par le nom de la classe. La fin de la dfinition est marquepar le mot-cl "end". Notre classe ici ne fait donc rien, elle se contente d'exister.

Il ne nous reste plus qu' en crer une instance en utilisant la mthode "new".

Nous allons dfinir certaines mthodes (simplistes) pour la classe "Animal". Un animal pourra donc "parler" ( dfautd'un meilleur terme), et aura un ge donn.

Il nous va donc falloir crire des mthodes permettant de dfinir des proprits et de les lire.

Une mthode se dfinit en commencant par le mot cl def, suivi par le nom de la mthode, puis le code de la mthode,et se termine par le mot cl end.

Modifions donc notre fichier comme suit :

class Animal def set_parle(parole) @parole = parole end

def get_parle return @parole end

def set_age(age) @age = age end

def get_age return @age endend

cochon = Animal.newcochon.set_parle("groin groin")cochon.set_age(12)

puts "le cochon fait #{cochon.get_parle}"




puts "le cochon a #{cochon.get_age} ans"

Pour excuter ce programme, ouvrez une fentre DOS, places-vous dans le rpertoire o se situe votre fichier"animaux.rb", et tapez la ligne suivante :

ruby animaux.rb

Et voici ce que vous devriez obtenir en sortie :

le cochon fait groin groinle cochon a 12 ans

Beaucoup de modifications cette fois-ci.

Nous avons simplement dfini quatre mthodes : dfinition de l'ge, dfinition de la "parole", rcupration de l'geet rcupration de la "parole".

Les mthodes sont dfinies l'aide du mot-cl "def" suivi du nom de la mthode, et se terminent par le mot-cl "end".

Mais pourquoi ces @ devant le nom des variables ? Tous simplement parce que ce sont des variables d'instance.Elles seront donc accessibles tout au long de la vie de notre objet, et de n'importe quel endroit de notre objet. Une foisque nous avons cre l'instance "cochon" de notre classe "Animal", nous dfinissons sa "parole" ainsi que son ge.

Ensuite, nous nous contentons d'afficher ces deux valeurs au sein d'une chane. Les balises #{...} permettent d'valuerdu code Ruby au sein d'une chane.

III-B - Constructeur : mthode initialize

Nous allons maintenant dfinir les comportements par dfaut de notre objet lors de sa cration. Placez le code suivantdans votre dfinition de classe :

def initialize @parole = "..." @age = 0 end

Et modifions la fin de notre fichier comme suit :

cochon = Animal.new

puts "le cochon fait #{cochon.get_parle}"puts "le cochon a #{cochon.get_age} ans"

cochon.set_parle("groin groin")cochon.set_age(12)

puts "le cochon fait #{cochon.get_parle}"puts "le cochon a #{cochon.get_age} ans"

Il ne nous reste plus qu' excuter notre fichier, et observer la sortie :




le cochon fait ...le cochon a 0 ansle cochon fait groin groinle cochon a 12 ans

En fait, la mthode initialize est une mthode spcifique, qui s'excute automatiquement lors de l'instanciation d'unobjet.

Ici donc, lors de la cration de notre objet "cochon", nous dfinissons qu'il ne sait pas parler ("..."), et qu'il est gde 0 ans.

Nous affichons ces proprits, puis nous les modifions et les r-affichons. Rien de trs compliqu ici.

C'est bien mignon, mais si il tait possible de dfinir des valeurs directement lors de la cration de l'objet, a nousarrangerait.

Et bien, c'est possible ! Il suffit de modifier la mthode initialize :

def initialize(parole="...", age=0) @parole = parole @age = age end

Nous pouvons donc dsormais crer un objet comme suit :

cochon = Animal.new("groin groin", 12)

Notre animal frachement cre saura donc immdiatement parler, et sera g de 12 ans.

Dans le cas o les paramtres auraient t oublis, ils auraient pris la valeur par dfaut dfinie dans la mthodeinitialize, savoir "..." et 0.

III-C - Variable de classe

Nous dsirons maintenant connatre tout instant le nombre total d'animaux crs. Modifiez donc votre fichier commesuit :

class Animal @@total_cree = 0

def initialize(parole="...", age=0) @@total_cree += 1 @parole = parole @age = age end

def self.total return @@total_cree end

def set_parle(parole) @parole = parole end




def get_parle return @parole end

def set_age(age) @age = age end

def get_age return @age endend

puts "Nombre total d'animaux crees : #{Animal.total}"

cochon = Animal.newputs "Nombre total d'animaux crees : #{Animal.total}"

chien = Animal.newputs "Nombre total d'animaux crees : #{Animal.total}"

chat = Animal.newputs "Nombre total d'animaux crees : #{Animal.total}"

Excutons le, et observons la sortie :

Nombre total d'animaux crees : 0Nombre total d'animaux crees : 1Nombre total d'animaux crees : 2Nombre total d'animaux crees : 3

Mais qu'est-ce donc que ce double arobase ? Il s'agit tout simplement d'une variable de classe. Sitt la classe dfinie,cette variable est accessible, puisque nous l'initialisons directement 0 (directement dans la classe).

A chaque instanciation d'un objet, nous incrmentons cette variable dans la mthode "initialize".

Nous avons galement cre une mthode "total", prcde du mot-cl "self". Ce mot-cl fait rfrence la classeelle-mme. Cette mthode se contente de renvoyer la valeur de la variable de classe.

Cette mthode tant une mthode de classe, il faut donc l'appeler depuis la classe, et non une instance de cetteclasse : "Animal.total".

III-D - Simplification de la classe grce Ruby

Nous allons maintenant profiter des possibilits de Ruby pour rendre la dfinition de notre classe plus lisible et plusfonctionnelle.

En effet, ne serait-il pas plus facile pour nous d'crire :

cochon.parle = "groin groin"puts cochon.parle

Plutot que :




cochon.set_parle("groin groin")puts cochon.get_parle

Je prfre nettement la premire des deux versions ;)

Et a tombe bien, Ruby nous permet de mettre en place de telles mthodes. Voyons comment, en remplaant lesmthodes set_parle et get_parle par les deux mthodes ci-dessous :

def parle=(parole) @parole = parole end

def parle return @parole end

Et appelons ces deux mthodes aprs l'instanciation de notre objet cochon :

cochon.parle = "groin groin"puts cochon.parle

Magie ! Le rsultat escompt est bien l, nous avons donc simplifi tant la lecture de notre dfinition de classe quel'utilisation des diffrentes mthodes.

Il s'agit simplement d'une preuve d'intelligence de Ruby. Si il rencontre la mthode parle, suivie d'une affectation (=),il sait tout seul quelle mthode appliquer.

Il ne nous reste plus qu' faire la mme chose avec nos mthodes "set_age" et "get_age".

def age=(age) @age = age end

def age return @age end

Nous allons prsent simplifier le code ci-dessus.

Pour commencer, les "return" prsents au sein de nos diffrentes mthodes sont inutiles, puisque Ruby renvoieautomatiquement la dernire expression value.

Ainsi, "return @parole" peut devenir "@parole" seul.

Nous remarquons maintenant que les mthodes cres pour avoir accs en lecture et en criture aux variables @ageet @parole sont trangement similaires et redondantes.

Pas de panique ! Ruby est l pour vous. Notre norme fichier plein de lignes va se transformer ainsi :

class Animal @@total_cree = 0 attr_accessor :parle, :age




def initialize(parle="...", age=0) @@total_cree += 1 @parle = parle @age = age end

def self.total @@total_cree endend

cochon = Animal.newcochon.age = 12puts cochon.ageputs cochon.parlecochon.parle = "groin groin"puts cochon.parle

Excutons notre code, et observons la sortie :

12...

groin groin

Simplement en utilisant la mthode "attr_accessor", nous avons raccourci notre code de 12 lignes. Cette mthodepermet de crer automatiquement des mthodes d'accs en lecture et en criture aux variables d'instance passesen paramtre.

Je sais que ce point est un peu dur saisir, mais Ruby va nous gnrer automatiquement les mthodes parle, parle=,age et age= qui vont nous permettre de lire ou de modifier les variables d'instance @age et @parle.

Nous avons donc au passage modifi notre mthode initialize pour remplacer @parole par @parle.

Si nous avions voulu accder uniquement en lecture nos variables, nous aurions pu utiliser "attr_reader", et"attr_writer" si nous avions voulu y accder uniquement en criture.

III-E - Et l'hritage alors ?

Nous allons nous essayer aux joies de l'hritage.

Pour cela, nous allons prendre un exemple parfaitement stupide : un animal est un tre vivant, et un tre vivant batdu c#ur.

Nous allons donc dfinir une classe "EtreVivant", dfinir une mthode "coeur_bat", et en faire hriter notre classe"Animal".

class EtreVivant def coeur_bat puts "boum boum, j'ai le coeur qui bat !" endend

Il ne nous reste plus qu' grer l'hritage proprement dit.




Modifiez donc la dfinition de la classe "Animal" comme suit :

class Animal




Vous pouvez vous en servir pour contrler les volutions de version de vos applications,redfinir une mthode existante dans un contexte particulier, ...

Vous pouvez galement la re-dfinir au sein d'une classe fille. La mthode aura donc uncomportement global, mais sera spcifique dans une classe prcise. Pour cela, il suffit deredfinir la mthode dans la classe voulue. Dans l'exemple ci-dessus, il aurait fallu dfinirla mthode coeur_bat pour la classe Animal.

Ainsi, la mthode coeur_bat serait reste la mme partout, sauf pour la classe Animal.C'est ce qu'on appelle la surcharge de mthodes.

De la mme faon, vous pouvez parfaitement tendre une classe existante, par exemple dfinir une mthode"je_parle_pas_clair" pour la classe String qui sera valable pour toutes les chanes :

class String def je_parle_pas_clair temp = self.reverse endend

texte = "Coucou les filles, ca va ?"puts texte.je_parle_pas_clair

Merveilleux non ? ;)

Il y a galement moyen de redfinir une mthode pour un objet spcifique. C'est ce qu'on appellera une mthodeSingleton.

Prenons cet exemple (parfaitement dbile, pardon petit frre mais j'tais en manque d'ides) :

class BeauGosse def la_classe puts "j'ai la classe" endend

titou = BeauGosse.newtitou.la_classe

petit_frere = BeauGosse.new

def petit_frere.la_classe puts "compare a mes grands freres, je vaut pas un clou !"end

petit_frere.la_classe

grand_frere = BeauGosse.newgrand_frere.la_classe

Et observons la sortie :

j'ai la classecompare a mon grand frere, je vaut pas un clou !j'ai la classe




Nous avons ici redfini la mthode "la_classe" uniquement pour l'objet "petit_frere".




IV - Et les modules, qu'est-ce que c'est ?

Les modules sont de petites choses qui ressemblent normment des classes, mais qui ne peuvent pas treinstancis.

En revanche, ils peuvent tout fait tre intgrs dans une classe, pour faire bnficier cette classe de l'ensembledes mthodes dfinies dans le module.

Voyons de suite un petit exemple (encore une fois ridicule et inutile, juste pour se rendre compte de la constructionet des possibilits) :

module ModTest def mon_id puts self.object_id endend

class ClassTest include ModTest # plein d'autres chosesend

class ClassTest2 include ModTest # plein d'autres choses diffrentes de la classe prcdenteend

toto = ClassTest.newtoto.mon_id

tata = ClassTest2.newtata.mon_id

Et l, miracle, nos deux classes hritent des mthodes de notre module.

Nous aurions pu envisager pour en arriver au mme rsultat d'ajouter la mthode une classe "suprieure" dans lahirarchie des classes, pourquoi pas la classe "Object" elle-mme, mais toutes nos classes n'ont pas besoin d'avoirces mthodes de dfinies.

Dans le cas prsent, nos deux classes peuvent appartenir deux branches trs diffrentes, et bnficier de la mmemthode.




V - Les structures de contrle

Pour les diffrentes structures de contrle ci-dessous, je vous montrerai simplement un exemple d'utilisation, je nepense pas qu'une explication soit ncessaire ;)

D'une manire gnrale, les structures de contrle s'appliquent tout ce qui est compris entre ne nom de l'instruction(if, while, ...) et le mot-cl end (parfois les instructions seront comprises entre accolades {...}).

IV-A - Oprateurs de comparaison

En Ruby, les oprateurs classiques de comparaison s'appliquent :

a == b : a gal b (attention, contrairement PHP par exemple, '42' == 42 renverra false) a != b : a diffrent de b a < b : a strictement infrieur b a > b : a strictement suprieur b a = b : a suprieur ou gal b

IV-B - if ... else ... end

puts "Merci de saisir un nombre : "chiffre = gets.chomp.to_iif (chiffre == 42) puts "Bingo, LA rponse !"else puts "Essaie encore"end

Notez simplement le to_i, qui transforme la valeur rcupre est un entier.

Dans le cas d'une suite de caractres alphanumriques, to_i a un comportementspcifique :

irb(main):001:0> "42".to_i=> 42irb(main):002:0> "42abc".to_i=> 42irb(main):003:0> "abc42abc".to_i=> 0irb(main):004:0> "abc".to_i=> 0

Tant que les caractres sont des chiffres, Ruby les prend en compte. Ds qu'il rencontre autre chose, il s'arrte. Dansle cas o le premier caractre de la chane ne correspond pas, il nous retourne 0.

IV-C - case ... end

Le case permet d'effectuer diffrentes actions en fonction de la valeur d'un paramtre sans avoir imbriquer trop de if.




puts "Merci de saisir un nombre : "chiffre = gets.chomp.to_icase chiffre when 0..9 puts "Vous aimez les tout petits chiffres." when 42 puts "Vous tre un as !" else puts "Vous auriez mieux pu choisir... ;)"end

La seule chose importante noter ici est l'intervalle spcifi dans le "when 0..9".

IV-D - unless ... end

Un unless est simplement un if l'envers : sauf si :

j = rand(10)unless (j = 10) puts i i += 1end

IV-G - for ... end

La boucle for est un peu particulire, puisqu'elle s'applique des lments d'une collection :

puts "compte de 1 a 10"for elt1 in (1..10) puts elt1




end

tableau = [1, 2, 3, 4]for elt2 in tableau puts elt2 + 1end

IV-H - each { ... } et autres itrateurs

Il est galement possible de coder les deux exemples ci-dessus comme suit :

puts "compte de 1 a 10"(1..10).each { |elt1| puts elt1}

tableau = [1, 2, 3, 4]tableau.each { |elt2| puts elt2 + 1}

Je prfre cette dernire syntaxe, mais ce n'est qu'une question de got personnel. Choisissez donc celle qui vousconvient le mieux.

Notez simplement que le dernier exemple pourrait s'crire ainsi :

tableau = [1, 2, 3, 4]tableau.each do |elt2| puts elt2 + 1end

Il est galement possible de parser un un les caractres d'une chane l'aide de each_byte :

ma_chaine = "ayu"ma_chaine.each_byte { |carac| ascii_sup = carac+1 puts ascii_sup.chr}

Merveilleux, nous avons augment notre code ASCII de 1, puis nous avons affich les lettres correspondantes.

Notez simplement la mthode "chr" appele l'affichage, pour afficher le caractre et non le code ASCII.

Il est galement possible de parser ligne par ligne. Je suis sr que vous avez dj devin le nom de l'itrateur...Bingo, each_line !

Affichons donc le numro de la ligne avant la ligne elle-mme :

ma_chaine = "toto\ntiti\ntata"i = 1




ma_chaine.each_line { |ligne| puts "#{i} : #{ligne}" i += 1}

Un petit moyen simple de rpter une opration X fois :

2000.times do puts "Moi, j'adore K2000 !" # Les Nulsend

IV-I - Sortie de boucles

Il existe diffrents moyens de sortir d'une boucle : "return", "break", "next" et "redo". Voyons les spcificits de chacun :

return : sort compltement de la boucle et de la mthode qui contient la boucle. break : sort de la boucle, et continue le code juste aprs. next : passe directement la prochaine itration de la boucle redo : re-passe l'itration courante de la boucle

Il est facile l'aide de ces commandes de raliser des boucles infinies. Prenez donc letemps de bien regarder comment elles fonctionnent.




VI - Procdures

Il est possible en Ruby de stocker des blocs de code dans des objets, pour mieux les excuter plus tard la demande :

quel_temps = Proc.new { |mon_param| puts "il fait #{mon_param} aujourd'hui"}quel_temps.call "gris"quel_temps.call "beau"

Merveilleux, notre code est excut. Ici, il ne s'agit que d'un simple affichage, mais il est possible d'avoir le codeque l'on veut dans une procdure.

Vous me direz, assez peu d'intrt dans l'tat. Mais l ou a devient sympathique, c'est que l'on peut passer uneprocdure en paramtre une mthode :

class Personne def initialize(age, sexe) @age = age @sexe = sexe end

def infos affiche_age puts "Je suis de sexe " + @sexe affiche_age.call @age end

end

monAgeH = Proc.new do |age| puts "J'ai "+age.to_s+" ans"endmonAgeF = Proc.new do |age| puts "On ne demande pas son age a une dame !"end

paul = Personne.new(42, 'masculin')virginie = Personne.new(32, 'feminin')

puts paul.infos(monAgeH)puts virginie.infos(monAgeF)

Ce qui va nous afficher :

Je suis de sexe masculinJ'ai 42 ansnilJe suis de sexe femininOn ne demande pas son age a une dame !nil

Nous avons donc pass un bloc de code en paramtre une mthode. Ce bloc peut varier du tout au tout, il ne serapas utile de modifier la mthode, ou de crer une deuxime classe similaire la premire.

Plutt avantageux non ?




VII - Gestion d'erreurs

Indispensable au dveloppeur, la gestion d'erreurs en Ruby est extrmement simple mettre en place.

VII-A - begin ... rescue ... end

Vous voulez ouvrir un fichier qui n'existe pas, crer une table qui existe dj ? Vous hassez cordialement lesmessages d'erreurs et les interruptions impromptues ?

Aucun soucis, dornavant, vous serez capable de grer ce genre de cas.

def ouvre_fichier(nom_fichier) begin fichier = File.open(nom_fichier, "r") rescue

puts "Le fichier n'a pas pu tre ouvert" endend

ouvre_fichier("test.txt")

Ne vous intressez pas pour le moment la manipulation de fichiers, cela fait l'objet de la section suivante.

Dans l'exemple ci-dessus, dans le cas ou le fichier "test.txt" ne peut tre ouvert, Ruby lve une exception, qui arrtel'excution du programme.

Mais le fait d'avoir mis l'instruction d'ouverture dans un bloc "begin ... rescue ... end" permet de capturer cette erreur,d'afficher un message (ou toute autre opration), puis de continuer l'excution du programme. Nous pourrions parexemple, au sein du "rescue", lui demander d'ouvrir un fichier par dfaut.

VII-B - ... retry ...

Grce l'instruction "retry", nous pouvons galement relancer notre bloc, en modifiant les paramtres par exemple :

def ouvre_fichier(nom_fichier) begin fichier = File.open(nom_fichier, "r") rescue

#demande l'utilisateur de saisir le nom du fichier puts "Le fichier n'a pas pu tre ouvert, merci de saisir un nom correct" nom_fichier = gets.chomp retry endend

ouvre_fichier("test.txt")

Attention tout de mme, dans ce cas prcis, nous bouclerons tant que l'utilisateur n'aura pas saisi un nom de fichierque Ruby est capable d'ouvrir.

Pensez donc grer ce cas ;)




VII-C - ... raise ...

Utiliser raise vous permet de lever vos propres erreurs, et de les traiter l'aide d'un rescue.

Voici un exemple parfaitement stupide, mais qui donne une ide de l'utilisation qui peut en tre faite :

begin puts "Saisissez LE nombre :" nombre = gets.chomp.to_i if (nombre != 42) raise "L'utilisateur ne connait pas ses classiques" endrescue

puts "Erreur : #{$!}"end

La seule chose noter ici est l'utilisation de "$!", qui retourne le dernier message d'erreur. Il s'agit d'une variableglobale spcifique (il y en a quelques autres dans le mme genre).

VII-D - .. ensure ...

Afin de s'assurer que dans tout les cas, une instruction s'excutera, il suffit d'utiliser "ensure" :

begin # Plein de code compliqurescue

# Une gestion de l'erreur qui fait plein de chose compliquesensure

# Un code qui s'excutera la fin, quel que soit le cas dans le quel on se trouve.end




VIII - Manipulation de fichiers

Les codes suivants vont tre moins dtaills, l'ide est plutt de voir diffrentes manires d'accder aux dossierset aux fichiers.

VIII-A - Cration de fichiers et de dossiers

Rien de trs compliqu dans cet exemple. Nous allons nous contenter de crer un dossier nomm "test" (avec lesdroits complets pour tout le monde), et de crer dans ce dossier un fichier vide nomm "test.txt" :

Dir::mkdir("test", 0777)File::new("test/test.txt", "w+")

Comme nous n'avons pas l'intention de travailler plus avant ni sur le dossier, ni sur le fichier, inutile de les instancier,nous allons directement faire appel la classe.

VIII-B - Afficher le contenu d'un fichier ligne par ligne avec le numro de ligne

fichier = File.open("test.txt", "r")i = 1fichier.each_line { |ligne| puts "#{i} - #{ligne}" i += 1}fichier.close

Notez simplement l'utilisation de "each_line", qui se tape tout le boulot notre place, pour notre plus grand plaisir ;)

La classe "File" hritant de la classe "IO", nous aurions pu faire la mme chose comme suit :

tableau = File.readlines("test.txt")i = 1tableau.each { |ligne| puts "#{i} - #{ligne}" i += 1}

Pas de grande diffrence, mais uniquement pour bien se rendre compte qu'il existe diffrents moyens de faire unemme chose ("IO.readlines" aurait galement convenu).

VIII-C - Ecrire dans un fichier

Il est trs facile d'crire dans un fichier en Ruby :

mon_tabl = ["Bonjour,", "Content de vous rencontrer.", "a va bien ?"]

mon_fichier = File.open("test.txt", "w")mon_tabl.each { |element| mon_fichier.write element+"\n" #mon_fichier




}mon_fichier.close

Bien entendu, l'effet produit va dpendre des diffrents modes d'ouverture du fichier utiliss.

La ligne commente n'est l que pour montrer quelle solution aurait galement pu tre utilise. Libre vous de choisircelle qui vous convient le mieux.

VIII-D - Renommer un fichier

C'est vraiment pour dire, mais rien de bien compliqu. Renommons notre fichier "test.txt" en "toto.txt" :

File::rename("test.txt", "toto.txt")

Vous tiez prvenus, c'est vraiment pour faire joli ;) Mais vous pouvez galement vous servir de cette commandepour dplacer un fichier.

VIII-E - Lister le contenu d'un rpertoire et de ses sous rpertoires tri par ordre alphabtique

Un bout de code lgrement plus complexe, mais qui peut servir : nous allons ajouter la classe "String" une mthode"liste_rep" qui lorsqu'elle recevra un path en paramtre listera celui-ci et tout ses sous-rpertoires :

class String def liste_rep(espacement = "")

liste_exclus = [".", ".."] d = Dir.open(self)

liste_dir = d.sort - liste_exclus

liste_dir.each { |fichier| case File.ftype(self+fichier) when "directory" puts "#{espacement} + #{fichier}/" espacement += " " (self + fichier + "/").liste_rep(espacement) espacement = espacement[0, espacement.length-4] when "file" puts "#{espacement} - #{fichier}" end } endend

"./".liste_rep

Plusieurs points importants ici :

L'utilisation de "self" permet de savoir tout moment quel est l'objet trait, puisqu'il s'agit de l'objet appelant lamthode. Cela permet de plus d'viter de passer un paramtre optionnel dans notre mthode.

L'opration de soustraction sur les tableaux est autorise. Ici, nous nous en servons pour exclure de la liste desfichiers parcourir les dossiers "." et "..", histoire d'viter de nous retrouver dans des boucles bizarres ;)




Nous nous contentons ensuite de vrifier le type du fichier. Si c'est un dossier, on l'affiche, on augmente l'indentation,on fait un appel rcursif sur la fonction, ... puis on dcrmente l'indentation

Si c'est un fichier normal, on se contente de l'afficher avant de passer l'lment suivant.




IX - Bases de donnes - MySQL

Dans cet exemple, nous allons nous pencher exclusivement sur MySQL, mais sachez que Ruby est capabled'attaquer tout type de bases de donnes.

IX-A - Installer MySQL pour Ruby

Commencez par tlcharger et installer MySQL en vous rendant sur la page de tlchargement MySQL.

Une fois install et configur, il ne vous reste plus qu' installer le module MySQL pour Ruby. Rien de plus simple,grce un systme de packages trs bien conu : Gem.

Ouvrez une invite de commande, et tapez "gem install mysql".

Aprs une mise jour des packages disponibles, il vous proposera une liste vous permettant de choisir quelle versiondu module vous souhaitez installer. J'ai opt pour celle-ci : "1. mysql 2.7.1 (mswin32)". Il vous suffit de taper le numrocorrespondant, et de valider avec la touche "Entre".

Il va se charger de tout installer, il ne vous reste plus qu' vrifier que cela fonctionne, en lanant irb, et en tapant :require "mysql". Si il vous renvoie "true", bingo c'est gagn, nous pouvons donc nous attaquer au code :)

IX-B - Exemple d'utilisation

Cette fois encore, le code sera plus parlant qu'un long discours :

require "mysql"

db_host = "localhost"db_user = "root"db_pass = "mon_pass"db_name = "base_test"

# Connexion MySQLconnex = Mysql.new(db_host, db_user, db_pass)

# Cration d'une base de teststrSQL = "CREATE DATABASE #{db_name}"begin connex.query(strSQL)rescue

puts "### Impossible de creer la base ###"end

# Connexion cette baseconnex.select_db(db_name)

# Cration d'une tablestrSQL = "CREATE TABLE liste_livres ( id_livre INT NOT NULL AUTO_INCREMENT PRIMARY KEY, titre VARCHAR(255) NOT NULL, auteur VARCHAR(50) NOT NULL, editeur VARCHAR(50) NOT NULL )"




begin connex.query(strSQL)rescue

puts "### Impossible de creer la table ###"end

# Remplissage de la basestrSQL = [ \ "INSERT INTO liste_livres (titre, auteur, editeur) \ VALUES('Le guide du voyageur galactique', 'Douglas Adams', 'Gallimard')", \ "INSERT INTO liste_livres (titre, auteur, editeur) \ VALUES('Dune', 'Frank Herbert', 'Robert Laffont')", \ "INSERT INTO liste_livres (titre, auteur, editeur) \ VALUES('Fondation', 'Isaac Asimov', 'Gallimard')", \ "INSERT INTO liste_livres (titre, auteur, editeur) \ VALUES('La pierre et le sabre', 'Eiji Yoshikawa', 'J\\'ai Lu')", \ "INSERT INTO liste_livres (titre, auteur, editeur) \ VALUES('La parfaite lumire', 'Eiji Yoshikawa', 'J\\'ai Lu')" \ ]begin strSQL.each { |ligne| connex.query(ligne) }rescue

puts "### Impossible d'inserer les donnees dans la base ###"end

# Un petit exemple de requte...strSQL = "SELECT * FROM liste_livres ORDER BY titre"result = connex.query(strSQL)result.each_hash do |ligne| puts "Titre : #{ligne['titre']}" puts "Auteur : #{ligne['auteur']}" puts "Editeur : #{ligne['editeur']}" puts "-------------------------------------------------"end

# Ferme la connexion la DBconnex.close

Voici les choses importantes retenir ici :

require "mysql" : charge le module MySQL, et permet d'utiliser les classes et mthodes lies. Mysql#new : cre la connexion la base de donnes. Mysql#select_db : dfinit la base sur laquelle travailler. Mysql#query : envoie une chane SQL la base. Mysql#close : ferme la connexion la base.

Notez simplement l'utilisation du backslash ("\") en fin de ligne lors du remplissage de la base, qui me permet d'viterdes sauts de ligne intempestifs (et puis, c'est nettement plus facile lire que tout la suite).

Je vous laisse vous amuser un peu avec les bases, mais rien de trs compliqu ici.





Vous avez maintenant acquis les bases de Ruby, il ne tient plus qu' vous de continuer travailler cet excellentlangage.

Un gros merci Zfred ainsi qu' Ricky81 pour leur conseils et leur relecture attentive.

J'espre que ce tutoriel vous aura t utile, et n'hsitez pas venir poser vos questions sur le forum Ruby, ou consullter la FAQ Ruby / Rails.

Vous pouvez galement vous initier Ruby on Rails.




SynopsisSommaireI - Installation et concepts de baseII - Premiers pasII-A - Manipulation de variables simplesII-B - TableauxII-C - Hash / tableaux associatifsII-D - Manipulation de chanes, de tableaux et de hashII-E - Conventions de nommageII-F - Expressions rgulires

III - Cration de notre premire classeIII-A - Dfinition de la classe et de ses mthodes, variables d'instanceIII-B - Constructeur : mthode initializeIII-C - Variable de classeIII-D - Simplification de la classe grce RubyIII-E - Et l'hritage alors ?III-F - Redfinir une mthode

IV - Et les modules, qu'est-ce que c'est ?V - Les structures de contrleIV-A - Oprateurs de comparaisonIV-B - if ... else ... endIV-C - case ... endIV-D - unless ... endIV-E - while ... endIV-F - until ... endIV-G - for ... endIV-H - each { ... } et autres itrateursIV-I - Sortie de boucles

VI - ProcduresVII - Gestion d'erreursVII-A - begin ... rescue ... endVII-B - ... retry ...VII-C - ... raise ...VII-D - .. ensure ...

VIII - Manipulation de fichiersVIII-A - Cration de fichiers et de dossiersVIII-B - Afficher le contenu d'un fichier ligne par ligne avec le numro de ligneVIII-C - Ecrire dans un fichierVIII-D - Renommer un fichierVIII-E - Lister le contenu d'un rpertoire et de ses sous rpertoires tri par ordre alphabtique

IX - Bases de donnes - MySQLIX-A - Installer MySQL pour RubyIX-B - Exemple d'utilisation


Documents

Premiers Pas Avec Ruby