News | Documentations | Association | Communauté | À propos de Ruby Liens |

Structures de contrôle

Ce chapitre poursuit l’exploration des structures de contrôle en ruby.

case

On utilise l’instruction case pour tester une suite de conditions. Elle est en gros semblable au switch de C et Java mais beaucoup plus puissante, comme nous allons le voir.

ruby> i=8
ruby> case i
   | when 1, 2..5
   |   print "1..5\n" 
   | when 6..10
   |   print "6..10\n" 
   | end
6..10
  nil

2..5 est une expression qui désigne la tranche de valeurs (range) entre 2 et 5, bornes incluses. L’expression suivante teste si la valeur de i est dans cet intervalle :

(2..5) === i

case utilise en interne l’opérateur relationnel === pour tester plusieurs conditions en même temps. En restant dans l’orientation objet de ruby, === est interprété selon la nature de l’objet qui apparaît dans le when. Par exemple, le code suivant teste l’égalité de chaînes de caractères dans le premier when, et la réussite d’une expression régulière dans le second.

ruby> case 'abcdef'
   | when  'aaa', 'bbb'
   |   print "aaa or bbbn" 
   | when /def/
   |   print "includes /def/n" 
   | end
includes /def/
  nil

while

Ruby fournit des moyens commodes de construire des boucles, encore que vous allez voir au prochain chapitre qu’en apprenant à utiliser des itérateurs vous n’aurez plus si souvent à écrire des boucles explicites.

Un while est un if répété. Nous l’avons utilisé dans notre programme de devinette et dans le programme avec les expressions régulières (voir le chapitre précédent); où il prenait la forme while condition … end entourant un bloc de code à répéter tant que condition était vrai. Mais while et if peuvent aussi bien s’appliquer à des instructions individuelles :

ruby> i = 0
 0
ruby> print "C'est un zéro.n" if i==0
C'est un zéro.
 nil
ruby> print "C'est un négatif.n" if i<0
 nil
ruby> print "#{i+=1}n" while i<3
1
2
3
  nil

Il arrive qu’on veuille tester une condition négative. Un unless (sauf si) est un if négatif, et un until (jusqu’à ce que) est un while (tant que) négatif. Nous vous laissons le soin de les essayer.

Il y a quatre moyens de rompre une boucle. Premièrement, break fait, comme en C, quitter la boucle complètement. Deuxièmement, next saute au début de la prochaine itération de la boucle (cf le continue du C). Troisièmement, ruby a le redo, qui répète l’itération courante. Ce qui suit est du code C qui illustre break, next, et redo :

while (condition) {
label_redo:
  goto label_next        /* next */
  goto label_break       /* break */
  goto label_redo        /* redo */
  ;
  ;
label_next:
}
label_break:
;

La quatrième façon de rompre une boucle est return. Une évaluation return fait sortir non seulement de la boucle mais aussi de la méthode qui contient la boucle. Si un argument est fourni, il sera retourné à l’appelant de la méthode, sinon c’est un nil qui sera rendu.

for

Les programmeurs C doivent se demander maintenant comment on fait une boucle “for”. Le for de ruby est un peu plus intéressant que vous ne le croyez peut-être. La boucle ci-dessous s’exécute une fois pour chaque élément de la collection :

for elt in collection
 ...
end

La collection peut être un intervalle de valeurs (c’est à cela que pensent la plupart des gens en parlant de boucles for) :

ruby> for num in (4..6)
   |    print num,"\n" 
   | end
4
5
6
  4..6

Elle peut aussi être n’importe quelle autre sorte de collection, comme un tableau :

ruby> for elt in [100,-9.6,"pickle"]
   |    print "#{elt}\t(#{elt.type})\n" 
   | end
100    (Fixnum)
-9.6   (Float)
pickle (String)
  [100, -9.6, "pickle"]

Mais nous anticipons un peu, car for est en somme une autre façon de dire each (pour chaque), qui, comme par hasard, est notre premier exemple d’un itérateur. Les deux formes ci-après sont équivalentes :


 # Si vous connaissz C ou Java, vous préférerez peut-être ceci:
 for i in collection
  ...
 end

 # Un programmeur Smalltalk , quand à lui, préférera:
 collection.each do |i|
  ...
 end

Les itérateurs peuvent souvent remplacer les boucles conventionnelles, et quand on y est habitué, on les trouve plus faciles. Alors, allons-y et voyons en plus sur eux.

Guide de l’utilisateur

Précédent : GDU : Retour sur les exemples Suivant : GDU : Itérateurs