L'interpréteur interactif IRB peut s'utiliser facilement comme calculatrice :

Ruby est capable d'évaluer toutes les opérations arithmétiques de base :

Pour quitter le programme IRB, il suffit d'entrer exit :

Nous allons maintenant jouer un peu plus avec les opérations arithmétiques de base. Essayez ceci :

Remarquez bien le comportement de Ruby lorsque nous essayons de diviser 3 par 2 :

Que s'est-il passé ? Rien d'anormal, je vous rassure! Ruby nous montre simplement qu'il travaille avec deux classes différentes de nombres :

• Entiers
• Décimaux (appelés aussi « flottants »)

1-1-B-1. Entiers▲

1-1-B-2. Décimaux▲

Un nombre décimal est souvent appelé «flottant», par analogie avec sa partie décimale. 3.14, 1.5 et 3.0 sont des flottants. Ruby renverra toujours une valeur flottante comme résultat pour des opérations arithmétiques agissant sur des flottants. Par exemple :

Avant d'en finir avec ce chapitre, jetons un petit coup d'oeil à deux autres opérateurs arithmétiques :

Notez bien le comportement de l'opérateur % avec les nombres décimaux. Dans cet exemple, 2 rentre deux fois dans 5.1, et il reste 1.1 de trop.

Ruby convient très bien lorsqu'il s'agit de travailler avec de très grands et de très petits nombres. Supposez par exemple que vous souhaitez enregistrer quelque part le nombre 192349562563447.

Bon, c'est loin d'être facile à lire. Dans la vie courante, nous sommes habitués à séparer les chiffres par des caractères spéciaux, en fonction du pays d'origine (il s'agit souvent d'une virgule, d'un point ou d'un espace blanc). Par exemple, nos amis anglo-saxons auraient représenté ce fameux nombre de cette façon : 192,349,562,563,447. Ruby fonctionne exactement de la même façon, en utilisant des «blancs soulignés» (en anglais, «underscores») :

Comment faire si vous désirez travailler avec des nombres énormes comme 17_000_000_000_000_000_000, ou des nombres minuscules comme 0.000_000_000_000_321? En temps normal, la méthode la plus simple (et la plus paresseuse) consiste à utiliser une notation scientifique en écrivant 1.7 x 1019, et 3.21 x 10-13. Et comme vous vous en seriez douté, Ruby permet évidemment d'utiliser cette notation :

1. Calculez le nombre d'heures contenues dans année.
2. Calculez le nombre de minutes dans une décénie.
3. Quel est votre age en secondes?
4. Que vaut l'expression 3.24 * ((34/2) - 54)/33.4 * 3.4 ? (notez qu'il est possible d'utiliser des parenthèses)
5. Quel sera le résultat d'une opération qui combine à la fois des flottants et des entiers? Par exemple, calculez ceci : 3.0 / 2 ; 3 / 2.0 ; 4 ** 2.0 ; 4.1 % 2

La réponse sera-t-elle donnée sous forme entière ou décimale?

Voici quelques trucs amusants que Ruby vous permet de faire avec des chaînes de caractères :

Voici un moyen de s'en souvenir : "salut " * 3 fait la même chose que "salut " + "salut " + "salut " , ce qui nous donnera donc "salut salut salut " .

Remarquez ce qu'il se passe lorsque nous retirons l'espace blanc de "salut " :

Maintenant, regardez ceci :

Ruby considère "1" comme étant une chaîne de caractères, pas un nombre.

Voici quelques méthodes utiles qui travaillent avec des chaînes de caractères :

Quel sera le résultat de l'expression suivante : 'Bonjour '.length + 'monde!'.length ?

Soyez certain de bien comprendre la différence entre une classe et un objet. Un objet, c'est une donnée quelconque. Une classe, c'est la structure de l'objet, ce à quoi il ressemble, ce qui le différencie des autres objets.

Par exemple, 3 et 5 sont des nombres différents. Ce sont donc des objets différents. Mais ce sont tous deux des nombres entiers, donc ils appartiennent à la même classe («Integer»). Voici quelques exemples :

Souvenez-vous, différentes classes peuvent avoir différentes méthodes. Voici quelques différences que nous avons déjà remarqué dans ce chapitre :

• L'opérateur de division (/) ne fonctionne pas de la même façon avec des entiers et des flottants.
• L'opérateur d'addition (+) se comporte différemment avec des nombres et des chaînes de caractères. Il peut servir à calculer le résultat de l'addition de deux nombres, et il peut également concaténer deux chaînes de caractères.
• Les chaînes de caractères possèdent plusieurs méthodes que les entiers et les flottants n'ont pas. Par exemple : capitalize, length, upcase, etc..

Pour cette raison, nous utiliserons la notation Classe#méthode pour identifier exactement de quelle méthode nous parlerons. Par exemple, nous dirons Integer#+ afin de différencier cette méthode de Float#+ et de String#+. Nous pouvons également affirmer que String#upcase existe, mais que Integer#upcase n'existe pas.

Voici quelques méthodes permettant d'effectuer des conversions pour les trois classes que nous venons d'étudier :

Un petit exemple pratique avec notre ami IRB :

Vous pouvez demander à Ruby si un objet est issu d'une classe particulière. Essayez ceci dans l'interpréteur :

12.is_a?(Integer)
12.is_a?(Float)
12.is_a?(String)
 
'12'.is_a?(Integer)
'12'.is_a?(Float)
'12'.is_a?(String)
 
12.0.is_a?(Integer)
12.0.is_a?(Float)
12.0.is_a?(String)

Essayez également ceci :

12 + 12
'12' + '12'
 
'12'.to_i + 12
'12' + 12.to_s
 
12 * 12
'12' * 12

Avez-vous obtenu les résultats que vous espériez?

Comment expliqueriez-vous la différence entre 12, '12' et 12.0 à un enfant?

Vous pouvez manipuler des variables exactement de la même façon que vous auriez manipulé les objets qu'elles représentent. Voici un exemple:

L'avantage des variables, c'est que vous pouvez garder quelque part une trace de vos données facilement. Imaginez par exemple que l'on vous donne les instructions suivantes :

1. Additionnez ensemble 2, 4, 6 et 8
2. Prenez le résultat, et divisez-le par 5
3. Calculez le produit simultané de 2, 3 et 4
4. Prenez le résultat obtenu à la ligne 2, et soustrayez-y ce que vous venez d'obtenir à la ligne 3

Bien entendu, vous pouvez écrire une longue expression pour calculer ceci. Mais il est évidemment plus facile d'écrire :

Dans l'exemple ci-dessus, nous avons vu les expressions :

x = x / 5
y = y - x

On rencontre assez souvent ce genre d'expressions, donc Ruby (qui pense à nous) nous permet d'utiliser les raccourcis suivants :

Donc, notre exemple du dessus aurait pu être écrit de cette façon :

Les constantes ressemblent à des variables, à la différence près que vous informez Ruby que sa valeur est supposée ne pas changer. Si vous essayez de modifier la valeur d'une constante, Ruby vous enverra un avertissement.

Vous pouvez définir des constantes de la même façon que des variables, sauf que leur nom doit commencer par une majuscule.

Même si Ville est une constante, sa valeur change quand même. Définir une constante signifie seulement que Ruby vous avertira si vous modifiez sa valeur. Regardez :

Pensez-vous que les raccourcis fonctionnent également avec les chaînes de caractères? Essayez ceci :

var = "Bonjour "
var += "monde"

À votre avis, que va donner ce code :

var = "salut"
var *= 3

Essayez-le. Comment auriez-vous expliqué le résultat à un enfant?

Ouvrez votre éditeur favori, et entrez-y la ligne suivante :

puts "Bonjour monde"

Sauvez le fichier sous le nom de bonjour.rb et démarrez-le en invoquant

ruby bonjour.rb

puts est une méthode qui affiche une chaîne de caractères sur le terminal.

Voici un nouvel exemple :

Regardez bien ce que nous avons fait. nom est une chaîne de caractères. Donc, nous pouvons la concaténer à d'autres chaînes de caractères, comme nous avons vu précédemment.

Dans un programme Ruby, seules les lignes passées à puts seront affichées à l'écran.

Souvenez-vous, dans la section précédente, nous avions entré ceci dans IRB :

Nous allons créer un nouveau programme Ruby à partir de ce code. Copiez simplement les lignes dans un nouveau fichier, et rajoutez-y à la fin la ligne suivante :

puts y

Ensuite, sauvez le fichier et invoquez Ruby :

Ça fonctionne! Cependant, nous aimerions modifier un peu le message de sortie. L'idéal serait que le programme affiche «La réponse est 20» à l'écran. On peut toujours essayer ceci :

puts "La réponse est " + y   # provoquera une erreur

Ça ne marchera évidemment pas. Pourquoi? Souvenez-vous, seules des chaînes peuvent-être concaténées à d'autres chaînes. Nous devons donc convertir notre entier y en chaîne de caractères. Nous savons qu'il faut utiliser la méthode Integer#to_s.

Si vous travaillez sur un système compatible UNIX (Linux, *BSD, Solaris, Cygwin + Win32...), vous pouvez rendre vos programmes Ruby exécutables. Ils pourront donc être démarrés de la même façon que les autres programmes.

Premièrement, nous devons savoir ou se cache Ruby sur votre machine. Pour ce faire, entrez la commande which ruby dans un terminal :

Recopiez le chemin sur la toute première ligne de votre programme. N'oubliez pas de préfixer la ligne par #!.

Il ne reste plus qu'à spécifier l'attribut du programme, ce que fera la commande chmod +x prog.rb (+x signifie «exécutable») :

Transformez en programme les exercices vus dans la section précédente.

Complétez le code suivant :

nom = "Laurent"
age = 22

Le programme doit afficher "Laurent a 22 ans".

Voici certaines choses dont vous devriez tenir compte lors du choix des noms de variables.

1-6-A-1. Noms significatifs▲

1-6-A-2. Noms composés▲

Vous ne devez pas arrêter d'utiliser IRB maintenant que vous savez comment utiliser votre éditeur pour écrire des programmes Ruby. Nous vous avons montré IRB tout au début pour une bonne raison. Lorsque vous programmerez avec Ruby, vous devriez toujours garder un terminal ouvert avec IRB, et y retourner pour expérimenter vos idées.

IRB a été conçu dans cette optique d'utilisation. Si vous l'utilisez judicieusement, vous deviendrez un bon programmeur Ruby.

Utilisez toujours des constantes pour représenter des valeurs fixes dans vos programmes. Il s'agit d'une bonne précaution, car Ruby vous aidera à identifier des erreurs potentielles dans votre code.

Quelques exemples :

Pi = 3.14159265
Masse_electron  = 9.109e-31
Vitesse_lumiere = 3e8
Distance_terre_soleil = 5.79e10

Essayez également d'éviter d'écrire directement des valeurs numériques. Utilisez des constantes pour rendre votre code plus lisible. Par exemple, la formule pour calculer l'aire d'un cercle est la suivante :

aire = pi . r²

r = rayon

Votre code doit se rapprocher au maximum de la formule. Voici ce qu'il faut faire, et ce qu'il ne faut pas faire :