De choses et d'autres
Ce chapitre traite de divers problèmes pratiques.
Délimiteurs d’instruction
Certains langages requièrent l’emploi d’une certaine ponctuation, souvent un point-virgule (;), pour terminer toutes les instructions d’un programme. Au lieu de cela, ruby suit la convention des shells unix comme sh et csh. Les instructions multiples sur une même ligne doivent être séparées par des point-virgules, mais ils ne sont pas imposés en fin de ligne, une fin de ligne étant traitée comme un point-virgule. Si une ligne se termine sur un antislash (’’), la fin de ligne qui suit est ignorée, ce qui vous permet d’avoir une unique ligne logique étalée sur plusieurs lignes physiques.
Les commentaires
Pourquoi écrire des commentaires ? Un code bien écrit tend à être auto-documenté, mais il est souvent utile de mettre des annotations dans les marges, et cela peut être une erreur de croire que les autres seront capables de regarder votre code et de tout suite voir les choses comme vous. En plus de cela, vous-mêmes, pour des raisons évidentes, serez une autre personne dans quelques jours… Qui de nous n’a pas dit, revenant après quelques temps sur un programme qu’il a écrit, « je sais que c’est moi qui ai écrit ça, mais bon dieu, qu’est-ce que ça peut bien vouloir dire ? »
Certains programmeurs expérimentés signaleront, assez justement, que des commentaires en contradiction avec le code, ou en retard sur lui peuvent être pires que pas de commentaires du tout. Sans doute, les commentaires ne devraient pas se substituer à un code lisible ; si votre code est peu clair, il est probablement aussi buggé. Vous éprouverez peut-être aussi plus le besoin de commenter pendant que vous apprendrez ruby, et puis de moins en moins au fur et à mesure que vous apprendrez à exprimer vos idées d’une façon simple, élégante et lisible.
Ruby suit une convention commune aux langages de script, qui est d’utiliser un signe dièse (#) pour indiquer le début d’un commentaire. Tout ce qui suit un # non entouré de guillemets ou d’apostrophes, jusqu’à la fin de la ligne, est ignoré par l’interpréteur.
De plus, pour faciliter la mise en commentaire de grands blocs, l’interpréteur ignore aussi tout ce qui est entre une ligne commençant par ”=begin” et une autre ligne commençant par =end”.
#!/usr/local/bin/ruby
=begin
*******************************************************
Ceci est un bloc de commentaire, quelque chose que
vous écrivez au profit d'un lecteur humain
(y compris vous-même). L'interpréteur l'ignore.
Pas besoin de '#' au début de ces lignes.
*******************************************************
=end
Organiser votre code
L’interpréteur ruby traite le code au fur et à mesure qu’il le rencontre. Il n’y a pas de phase de compilation ; si quelque chose n’a pas été lu, ce quelque chose est tout simplement indéfini.
# ceci provoque une erreur "undefined method" (méthode non définie):
print successor(3),"n"
def successor(x)
x + 1
end
Cela ne vous force pas pour autant, contrairement à ce que vous pourriez penser d’abord, à organiser votre code strictement de haut en bas. Quand l’interpréteur rencontre une définition de méthode, celle-ci peut sans inconvénient contenir des références non résolues, pourvu qu’elles le soient au moment où la méthode sera effectivement utilisée :
# Conversion de fahrenheit en celsius, décomposée en deux étapes
def f_to_c(f)
rapport (f - 32.0) # Voici une référence anticipée, mais ça va quand même.
end
def rapport(x)
x * 5.0 / 9.0
end
printf "%.1f est une température confortable.n", f_to_c( 72.3 )
Bien que ceci puisse vous paraître moins commode que ce que à quoi vous êtes peut-être habitué en Perl ou Java, c’est moins restrictif que d’essayer d’écrire du C sans prototypes (ce qui impose de conserver toujours un ordre relatif entre quoi appelle quoi). Vous pouvez toujours mettre le code de plus haut niveau à la fin de votre source. Et même c’est moins ennuyeux qu’il n’y parait d’abord. Une façon raisonnable et sans effort d’obtenir le comportement que vous voulez est de définir une fonction main au début de votre source, et de l’appeler de la fin.
#!/usr/local/bin/ruby
def main
# ici vous mettez votre code de plus haut niveau
end
# ... ici le code de réalisation, organisé comme vous voulez
main # ... et l'exécution commence ici
Il est d’un grand secours que ruby vous offre des outils pour décomposer des programmes compliqués en morceaux lisibles, réutilisables, logiquement reliés. Nous avons déjà vu l’utilisation de include pour accéder aux modules. Vous découvrirez aussi que load et require sont utiles pour cela. load marche comme si le fichier mentionné était copié et collé dans le source (un peu comme les directive de préprocesseur #include en C). require est un peu plus sophistiqué, car il fait que le code mentionné est chargé au plus une fois, et seulement si on en a besoin. Il y a d’autres différences entre load et require ; référez vous au manuel du langage ou à la FAQ pour plus d’informations.
Et voilà…
Ce tutorial devrait suffire pour commencer à écrire des programmes en ruby. Lorsque d’autres questions surgiront, vous pourrez vous plonger dans le manuel de référence (lien introuvable) pour en apprendre plus sur ruby. La FAQ et la library reference sont aussi des ressources importantes.
Bonne chance, et heureuse programmation !
Précédent : GDU : Initialisation des objets
