Table des Matières
Introduction ... 3
Interactive Ruby ... 3
Ruby… au doigt et à l’œil ... 4
Premiers pas en calcul ... 4
Les modules, ou comment regrouper le code par thématiques ... 5
Courte et morne vie d’une méthode… ... 7
Les chaînes des caractères ... 8
Introduction
Ce court tutoriel ne devrait pas prendre plus de vingt minutes de votre temps. Il part du principe que vous avez déjà installé Ruby ; si ce n’est pas le cas, il vous est chaleureusement conseillé de le faire avant de poursuivre votre lecture.
Note : le traducteur a ici considéré qu’il était plus pertinent de
conserver l’entièreté du code en anglais, plutôt que de présenter un mélange en « franglais » de mot-clés anglais et noms de variables français. L’usage d’un langage de programmation, quel qu’il soit, nécessite hélas (?) encore quelques notions essentielles dans la langue de Shakespeare.
Interactive Ruby
Une première approche de Ruby, la plus simple, consiste à utiliser IRB(Interactive Ruby) dans un terminal :
si vous utilisez Mac OS X, ouvrez un Terminal et tapez irb, puis
appuyez sur [Entrée] ;
si vous êtes sous Linux, ouvrez une console et tapez irb, puis
appuyez sur [Entrée] ;
si enfin, vous utilisez Windows, lancez fxri qui se trouve dans la
section Ruby du menu Démarrer > Applications.
IRB permet d’écrire et d’interpréter du Ruby à la volée, sans avoir à enregistrer un fichier et l’exécuter ensuite.
irb
(
main
):001:0>
Tapez ceci : "Hello World" et appuyez sur [Entrée] pour valider (ce que
vous devrez faire après chaque nouvelle ligne).
irb
(
main
):001:0>
"
Hello World
"
=>
"
Hello World
"
Ruby… au doigt et à l’œil
Que vient-il de se passer au juste ? Venons-nous d’écrire le plus court programme Hello World jamais vu ? Pas tout à fait… mais presque. La seconde ligne, celle débutant par le signe =>, est la façon
dont IRB nous informe du résultat de la dernière expression évaluée. Si nous voulons véritablement écrire « Hello World », il en faut un tout petit peu plus :
irb
(
main
):002:0>
puts
"
Hello World
"
Hello
World
=>
nil
puts est la commande de base pour écrire quelque chose avec Ruby. Et
qu’est-ce que nil que nous présente IRB ? Le résultat de notre
expression puts "Hello World", bien sûr ! En fait, puts retourne toujoursnil, qui
est, pour Ruby et bientôt, pour vous, l’absence totale de valeur.
Premiers pas en calcul
Il est très facile d’utiliser IRB comme une vulgaire calculatrice :
irb
(
main
):003:0>
3+2
=>
5
Trois plus deux. Assez facile, j’en conviens. Et quid de trois fois deux ? Notez ici que vous pouvez, si vous le voulez, appuyer sur la touche
[Flèche haut] pour rappeler la dernière ligne tapée dans IRB, et avec les flèches directionnelles et [backspace], remplacer le signe + par * :
irb
(
main
):004:0>
3*2
=>
6
Maintenant, essayons trois au carré :
irb
(
main
):005:0>
3**2
=>
9
Dans la syntaxe Ruby, ** est là pour signifier « à la puissance… » ; et
si vous souhaitez aller dans l’autre sens, à savoir obtenir la racine carré d’un nombre, vous écrirez ceci :
irb
(
main
):006:0>
Math.
sqrt
(9)
=>
3.0
Un peu moins trivial. Vous avez vraisembablement deviné que cela demandait la racine carré (Ndt : square root en anglais). Mais qu’est-ce que qu’est-ce Math ?
Les modules, ou comment regrouper
le code par thématiques
Math est ce qu’on appelle en Ruby, un module. Il vous est fournit
d’office (il fait partie de la bibliothèque standard, qui regroupe les modules d’intérêt général) et s’occupe, comme son nom l’indique, des mathématiques. Les modules ont deux grands rôles à jouer au sein de Ruby. L’exemple précédent illustre le premier de ces rôles : regrouper des méthodes (souvent désignées sous le vocable de « fonctions » dans d’autres langages). Par exemple, le module Math contient aussi, et
entre autres, les méthodes sin et tan, deux fonctions trigonométriques
biens connues.
Après Math venait, dans notre code source, un point « . » collé
entreMath et la méthode sqrt. Quel est son rôle ? Le point permet
d’identifier sans ambiguïté qui doit recevoir un message. La question se pose donc de savoir ce qu’est un « message » en Ruby. Dans notre, exemple, le message est tout simplement l’action désirée, à
savoir sqrt(9) : « récupérer la racine carrée du chiffre 9. » Pour Ruby, ce
message consiste à appeler la méthode sqrt, avec le paramètre 9, et à
retourner le résultat.
Comme vous le voyez dans IRB, le résultat de cet appel de méthode est la valeur numérique 3.0. Vous remarquerez ici que ce n’est pas
simplement l’entier naturel 3. Parceque bien souvent, le résultat d’une
racine carrée n’est pas un entier, la méthode retourne par défaut un nombre réel (du point de vue de l’ordinateur, un nombre à virgule flottante).
Si nous souhaitons conserver « quelque part » le résultat de cette opération mathématique, il suffit de l’assigner à une variable.
irb
(
main
):007:0>
a
=
3
**
2
=>
9
irb
(
main
):008:0>
b
=
4
**
2
=>
16
irb
(
main
):009:0>
Math.
sqrt
(
a
+
b
)
Bien, notre calculatrice est déjà un bon début, mais le sujet principal de ce tutoriel est le programme Hello World.
Admettons, pour la bonne continuité de ce tutoriel, que nous voulons tout à coup répéter et répéter encore « Hello World » ... mais sans trop nous fatiguer. Il va falloir définir une méthode.
irb
(
main
):010:0>
def
h
irb
(
main
):011:1>
puts
"
Hello World!
"
irb
(
main
):012:1>
end
=>
nil
Le mot-clé def a ici pour rôle de commencer la définition d’une
méthode. Il dit tout simplement à Ruby que nous [attention !] commençons à écrire [grands signes vers Ruby] une nouvelle
méthode, laquelle s’appelle h. La ligne suivante constitue le corps de
notre méthode ; en l’occurence, il s’agit de la ligne que nous avons écrite auparavant, puts "Hello World". Enfin, la dernière ligne, end, indique à
Ruby que la définition de la méthode s’arrête là. Après avoir appuyé sur [Entrée], Ruby répond… nil, ce qui est sa façon à lui de dire qu’il a
bien compris et enregistré notre nouvelle méthode.
Courte et morne vie d’une méthode…
Bien, essayons de faire fonctionner cette méthode deux ou trois fois, pour voir :irb
(
main
):013:0>
h
Hello
World!
=>
nil
Hello
World!
=>
nil
Rien de très compliqué. Appeler une méthode en Ruby, c’est
simplement dire son nom, au minimum. Si la méthode n’attend pas de paramètres pour préciser ce qu’elle doit faire, le nom suffira. Et
d’ailleurs, vous pouvez bien ajouter des paramètres à une méthode qui n’en attend pas : il seront simplement ignorés.
Que faire si nous souhaitons dire bonjour à une personne en
particulier, et pas au monde entier ? Et bien, il suffit justement de demander à ce que le nom de la personne concernée soit mentionné en tant que paramètre de la méthode h :
irb
(
main
):015:0>
def
h
(
name
)
irb
(
main
):016:1>
puts
"
Hello
#{name}
!
"
irb
(
main
):017:1>
end
=>
nil
irb
(
main
):018:0>
h
("
Matz
")
Hello
Matz!
=>
nil
Ça fonctionne… mais pourquoi ? et comment ?
Les chaînes des caractères
Le truc le plus étrange dans ce nouvel exemple est sûrement ce #{name}.
Il s’agit en fait du moyen le plus simple dont dispose Ruby
pourinsérer quelque chose au sein d’une chaîne de caractère. Le mot entre crochets, name, est à terme transformé en une chaîne de caractère
(sauf s’il en était déjà une, bien sûr) et incorporé à la chaîne qui
(name), vous pouvez lui passer des messages avec des méthodes… Par
exemple, lui demander de toujours débuter par une majuscule avec capitalize :
irb
(
main
):019:0>
def
h
(
name
=
"
World
")
irb
(
main
):020:1>
puts
"
Hello
#{name.capitalize}
!
"
irb
(
main
):021:1>
end
=>
nil
irb
(
main
):022:0>
h
"
chris
"
Hello
Chris!
=>
nil
irb
(
main
):023:0>
h
Hello
World!
=>
nil
D’autres petits ajouts ont eu lieu dans ce dernier bout de code. Tout d’abord, nous n’appelons plus la méthode avec des parenthèses autour du paramètre. Elles sont en effet optionnelles, et vous pouvez vous en passez si ce que vous écrivez est trivial, comme c’est le cas ici.
Ensuite, nous avons défini une valeur par défaut pour le
paramètre name. Si la méthode est appelée sans que lui soit fourni un
nom en particulier, alors le nom prendra la valeur "World".
Un brin de politesse
L’accueil donné actuellement par notre méthode est un peu frustre… il ne serait pas de trop d’avoir une formule plus respectueuse à
l’encontre de l’usager. Pour ce faire, nous utiliserons un objet. Et nous allons même dans la foulée créer une classe, “Greeter”.
irb
(
main
):024:0>
class
Greeter
irb
(
main
):025:1>
def
initialize
(
name
=
"
World
")
irb
(
main
):026:2>
@name
=
name
irb
(
main
):027:2>
end
irb
(
main
):028:1>
def
say_hi
irb
(
main
):029:2>
puts
"
Hi
#{@name}
!
"
irb
(
main
):030:2>
end
irb
(
main
):031:1>
def
say_bye
irb
(
main
):032:2>
puts
"
Bye
#{@name}
, come back
soon.
"
irb
(
main
):033:2>
end
irb
(
main
):034:1>
end
=>
nil
Évidemment, la nouveauté la plus importante ici est le mot-clé class.
Son rôle est de définir une nouvelle classe, en l’occurence Greeter,
laquelle classe contient plusieurs méthodes. Vous avez également repéré @name. Il s’agit d’une « variable d’instance », qui sera disponible
pour toutes les méthodes de la classe Greeter. Elle est d’ailleurs utilisée
par les méthodes say_hi et say_bye.
