Retour sur les exemples

Maintenant, nous allons revoir le code de certains de nos programmes exemples. Pour nous y référer plus commodément, nous numérotons les lignes.

Factorielles

Ce qui suit apparaissait dans le chapitre 3. des GDU : Des exemples simples.

01 def fact(n) 02 if n == 0 03 1 04 else 05 n * fact(n-1) 06 end 07 end 08 print fact(ARGV⁰.to_i), “\n”

Parce que c’est la première fois, nous allons examiner chaque ligne.

01 def fact(n)

Dans la première ligne, def est une instruction pour définir une fonction (ou, plus précisément, une Méthode ; mais nous parlerons plus en détail des méthodes plus loin). Ici, elle spécifie que la fonction fact reçoit un unique argument, nommé n.

02 if n == 0

Ce if (si) teste une condition. Quand la condition est remplie, la prochaine ligne est évaluée, sinon, c’est ce qui suit le else (sinon) qui est évalué.

03 1

La valeur de if est 1 si la condition est remplie.

04 else

Si la condition n’est pas vérifiée, le code depuis else jusqu’à end est évalué.

05 n * fact(n-1)

Si la condition n’est pas satisfaite, la valeur de if est n fois fact(n-1).

06 end

Ce premier end ferme l’nstruction if.

07 end

Le second end ferme l’instruction def.

08 print fact(ARGV⁰.to_i), “\n”

Ceci invoque notre fonction fact() en utilisant une valeur fournie par la ligne de commande, et imprime le résultat.

ARGV est un tableau qui contient les arguments de la ligne de commande. Les éléments de ARGV sont des chaînes de caractères, aussi devrons-nous les convertir en nombres entiers par to_i. Ruby ne convertit pas automatiquement les chaînes en entiers comme Perl le fait.

Hmmm… Qu’arriverait-il si nous fournissions à ce programme un nombre négatif ? Voyez-vous le problème ? Sauriez-vous le résoudre ?

Strings

Maintenant examinons le programme de devinette du chapitre sur GDU : Chaînes de caractères.

01 words = [‘foobar’, ‘baz’, ‘quux’] 02 secret = words[rand(3)] 03 04 print "guess? " 05 while guess = STDIN.gets 06 guess.chop! 07 if guess == secret 08 print “you winn” 09 break 10 else 11 print “you lose.n” 12 end 13 print "guess? " 14 end 15 print "the word is ", secret, “.n”

Dans ce programme, une nouvelle structure de contrôle, while (tant que), est présentée. Le code entre while et son end sera exécuté répétitivement tant qu’une certaine condition restera vraie.

rand(3) en ligne 2 retourne un nombre aléatoire dans la tranche de valeur 0 à 2. Ce nombre aléatoire est utilisé pour extraire un des éléments du tableau words.

En ligne 5 nous lisons une ligne depuis l’entrée standard par la méthode STDIN.gets. Si EOF (end of file – fin de fichier) survient pendant qu’on essaye de recueillir la ligne, gets rend nil (rien). Donc le code associé à ce while se répétera jusqu’à ce qu’il rencontre un ^D (ou ^Z sous DOS), qui signifie la fin de l’entrée.

guess.chop! en ligne 6 ôte le dernier caractère de guess; qui dans ce cas sera toujours un caractère newline (nouvelle ligne).

En ligne 15 on imprime le mot secret. Nous l’avons écrit en une instruction qui est un print avec trois arguments (qui sont imprimés l’un après l’autre), mais nous aurions aussi bien pu le faire avec un unique argument, en écrivant secret sous la forme #{secret} pour rendre manifeste que c’est une variable à évaluer, et non un littéral à imprimer tel quel :

print “the word is #{secret}.\n”

Expressions régulières

Enfin, examinons le programme du chapitre sur GDU : Expressions régulières.

01 st = “\033[7m” 02 en = “\033[m” 03 04 while TRUE 05 print "str> " 06 STDOUT.flush 07 str = gets 08 break if not str 09 str.chop! 10 print "pat> " 11 STDOUT.flush 12 re = gets 13 break if not re 14 re.chop! 15 str.gsub! re, “#{st}\\&#{en}” 16 print str, “\n” 17 end 18 print “\n”

En ligne 4, la condition pour le while est forcée à true (vrai), ce qui forme ce qui pourrait être une boucle infinie. Mais nous mettons des instructions break (rupture) en 8ème et 13ème lignes pour sortir de la boucle. Ces deux break sont aussi des exemples de if modifiés. Un if modifié exécute sa partie gauche si et seulement si la condition spécifiée est satisfaite.

Il y plus à dire sur le chop! (tronque) (lignes 9 et 14). En ruby, on attache conventionnellement un ‘!’ ou un ‘?’ à la fin de certains noms de méthodes. Le point d’exclamation (!, qu’on prononce parfois “bang!”) indique qu’il y a là quelque chose de potentiellement destructeur, c’est-à-dire quelque chose qui peut changer la valeur de ce qu’il touche. chop! modifie directement la chaîne concernée, tandis que chop sans point d’exclamation travaille sur une copie. Voici une illustration de la différence :

ruby> s1 = “forth” “forth” ruby> s1.chop! # Ceci change s1. “fort” ruby> s2 = s1.chop # Ceci met une copie modifiée de s1 dans s2, “for” ruby> s1 # … sans changer s1. “fort”

Vous rencontrerez plus loin des noms de méthodes se terminant par un point d’interrogation (?, quelquefois prononcé “huh?” – Ndt “hein?”) ; ceci indique une méthode de type « prédicat », c’est-à-dire qui retourne soit true (vrai) soit false (faux).

La ligne 15 mérite toute votre attention. D’abord notez que gsub! est aussi une méthode destructive. Elle change str en y remplaçant tout ce qui correspond à la forme re (sub signifie substitue, et le g du début siginfie global, c’est-à-dire, remplace toutes les parties de la chaîne qui correspondent, pas juste la première). Tout ça est très bien, mais on remplace les parties trouvées par quoi ? st et en ont été définies en lignes 2-2 comme les séquences ANSI qui mettent la couleur du texte en inverse et normal, respectivement. En ligne 15 elles sont entourées de #{} pour forcer leur interprétation (et que ce ne soit pas simplement le nom des variables qui soit imprimé). Entre elles nous voyons “\\&”. Ceci est un peu tortueux. Du fait que la chaîne de remplacement est entre guillemets, la paire d’antislashs sera interprétée comme un antislash simple ; que gsub! verra comme “\&”, qui se trouve être un code spécial qui désigne “ce qui a été trouvé par application de la forme précédente”. Donc la nouvelle chaîne imprimée sera identique à la chaîne initiale, sauf que les parties trouvées par la forme (l’expression régulière) seront en inverse vidéo.

Guide de l’utilisateur
Précédent : GDU : Tableaux Suivant : GDU : Structures de contrôle