Ici et ailleurs

Le blog d’un joueur … mais pas que le blog de Sky.

Ruby on Rails : Ruby et sa syntaxe part1

Maintenant que tout est en place et avant de commencer à parler de Rails, parlons un petit peu du langage que ce framework utilise, le Ruby.

Comme je l’ai déjà précisé dans mon précédent article, Ruby est un langage interprété et orienté objet. Si vous ne savez pas ce que cela signifie, je vous invite à cliquer sur le lien, je ne ferais pas de cours sur la POO ici et partirais du principe que vous en connaissez les bases.

Nous allons donc nous intéresser à la syntaxe du Ruby de manière générale afin de ne pas perdre de temps par la suite, et pour tester, rien de mieux qu’un bon vieux shell !

Hello IRB!

IRB pour Interactive Ruby shell permet de tester des commandes Ruby et d’avoir le retour directement, très pratique pour se faire la main, tout ce que vous créez dans le shell est valable tant que celui-ci est ouvert, pour reprendre à zéro, fermer et ré-ouvrer l’irb. Pour y’accéder, deux solutions :

  • Démarrer une console Windows puis taper irb, vous devriez voir apparaître un prompt commençant par irb<main> si vous avez bien ajouté les bin de Ruby au PATH lors de l’installation,
  • Exécuter le .bat : chemin\vers\installation\ruby\bin\irb.bat.

Voilà, normalement, vous avez une console devant vous et nous pouvons commencer.

Conventions de nommage

Mettons les choses au clair en ce qui concerne le nommage de nos méthodes, variables, classes, etc.. Par convention, en Ruby :

  • Le nom des classes commence par une majuscule,
  • Le nom des méthodes et variables est entièrement en minuscule (on peut utiliser des underscore “_” pour séparer deux mots),
  • Le nom des constantes est entièrement en majuscule

Ruby utilise la ponctuation dans les méthodes de manière à améliorer la lecture du code, ainsi, une méthode qui modifie l’appelant sera noté de cette manière : methode!, c’est à dire suffixé d’un point d’exclamation.

Une méthode qui retourne un boolean, donc true ou false sera suffixé d’un point d’interrogation comme ceci : methode?

Si tout cela vous semble confus, ne vous en faites pas, on utilisera des exemples un peu plus tard.

Quelques types

Voyons rapidement quelques types que nous serons (sûrement) amenés à utiliser.

String

Pour représenter une chaîne de caractères, fournit un grand nombre de méthodes pour la manipulation des chaînes.

irb> "Une chaîne de caractères"

Number

Des valeurs numériques, de classes Fixnum (ex: 123), Bignum (ex: 123465789101112), Float (ex: 1.2).

Range

Une suite de valeurs numériques entre les bornes précisées.

1..5 # contient les nombres 1, 2, 3, 4, 5
1...5 # contient les nombres 1, 2, 3, 4, la borne max ne faisant pas partie de la suite

Attention, noter bien la différence entre les deux points “..” et les trois points “…”.

Le symbole dièse “#” sert de notation pour les commentaires. La ligne qui figure après ce symbole ne sera pas interprétée.

Array

Les tableaux, comme dans tous les langages, permettent d’organiser des collections d’objets. On accède à un élément grâce à son index (sa position dans le tableau en partant de zéro). Plusieurs manières de déclarer un tableau :

  • Grâce à la méthode new de la classe Array,
  • En  initialisant le tableau lors de la création,
  • En utilisant la syntaxe %W( une chaine de caracteres ) qui créera un tableau de ce type ["une", "chaine", "de", "caracteres"].
irb> my_array = Array.new
=> []
irb> my_array[0] = "index 0";
=> "index 0";
irb> my_array.push(21)
=> ["index 0", 21]

Plusieurs manières d’ajouter un élément au tableau, ici je commence par préciser qu’à mon index 0 je place une chaîne et ensuite j’utilise la méthode push pour ajouter un objet Fixnum à la fin du tableau. Pour ajouter à la fin d’un tableau, on peut aussi utiliser l’opérateur << de cette manière :

irb> array = []
irb> array << 1
irb> array << "two"
=> [1, "two"]
irb> my_array2 = ["une", "chaine"]
=> ["une", "chaine"]
irb> my_array2[1]
=> "chaine"

Hash

Rapidement, c’est une sorte de dictionnaire dans lequel on fait correspondre une clé à une valeur. Plutôt que d’accéder à un élément par un index, on y’accède par une clé. Comme pour les tableaux, on peut le déclarer grâce à la méthode new (il est possible d’envoyer en paramètre la valeur retournée si la clé n’existe pas) de la classe Hash ou directement en l’initialisant grâce à des accolades comme ceci :

irb> my_hash = {
irb*   "hauteur" => 768,
irb*   "largeur" => 1024
irb> }
=> {"hauteur" => 768, "largeur" => 1024}
irb> my_hash["hauteur"]
=> 768

On sera sûrement amené à revoir les Hash et les Array, pour le moment, on se contentera de l’essentiel.

“Symbol”

Les “symbol” sont des identifiants textuels ressemblant à des Strings. Ils sont préfixés par un double point “:”. La différence principale est qu’ils contiennent moins de fonctions qu’une String normale. Du coup, ils sont plus légers et parfait, entre autre, pour mettre en tant que clé dans notre Hash plus haut. On a donc :

irb> reso = {
irb*   :hauteur => 768,
irb*   :largeur => 1024
irb> }
=> {:hauteur => 768, :largeur => 1024}
irb> reso[:largeur]
=> 1024

Les méthodes

En Ruby, les méthodes sont définies, comme les classes et les boucles, dans des blocs. Elles commencent par le mot clé def et se terminent par le mot clé end. A l’intérieur de ce bloc, on définit les instructions à exécuter. On commence par un exemple tout simple.

irb> def ma_methode
irb>   puts "Depuis ma_methode";
irb> end
=> nil # nil est l'équivalent de null
irb> ma_methode
=> "Depuis ma_methode";

Ce code crée donc une méthode ma_methode, qui écrit dans la console un message. Par défaut, la dernière valeur utilisée est retournée par la méthode Ruby, c’est un retour implicite. Pour effectuer un retour explicite, il suffit d’utiliser le mot clé return, dans notre cas, le résultat sera le même (irb doit être redémarrer pour redéclarer la méthode) :

irb> def ma_methode
irb>   return "Depuis ma_methode"
irb> end
=> nil
irb> ma_methode
=> "Depuis ma_methode"

On peut rajouter des paramètres, qui peuvent avoir des valeurs par défaut, et utiliser une liste de paramètres qui reste optionnelle. Les paramètres optionnels et les listes de paramètres doivent apparaître à la fin de la signature de la méthode. On a donc une méthode qui pourrait ressembler à ceci :

# On crée une méthode prenant : 1 paramètre obligatoire, 1 paramètre optionnel et 1 liste de paramètres optionnelles
irb> def avec_params(obligatoire, optionnel = "valeur par defaut", *liste)
irb>   "avec_params : " + obligatoire + ", " + optionnel + ", #{liste.join(', ')}"
irb> end
=> nil
irb> avec_params("param 1") # avec un paramètre
=> "avec_params :  param 1, valeur par defaut, "
irb> avec_params("param 1", "param 2") # avec deux paramètres
=> "avec_params :  param 1, param 2, "
irb> avec_params("param 1", "param 2", "liste 1", "liste 2") # avec une liste de paramètres en plus
=> "avec_params :  param 1, param 2, liste 1, liste2"

Vous aurez noté l’utilisation de la notation #{variable} qui permet d’écrire du code Ruby directement dans la chaîne de caractères. On aurait aussi pu l’utiliser pour les autres paramètres et se retrouver avec la ligne

"avec_params: #{obligatoire}, #{optionnel}, #{liste.join(', ')}"

qui n’aurait pas changé le résultat affiché par notre méthode. Vous aurez aussi noté l’utilisation de la méthode join sur la liste de paramètres qui permet d’afficher tous les éléments sous forme de String séparé par la chaîne envoyée en paramètre.

Les Proc

Les Proc permettent d’affecter un bloc de code à une variable. l’appel à la méthode call d’un objet Proc va appeler cette méthode. Il y’a certaine subtilité que nous ne verrons pas ici.

mon_proc = Proc.new {|param| puts "Ce proc est appele avec le parametre : " + param}
mon_proc.call("OMG");
=> Ce proc est appele avec le parametre OMG

Dans le même genre, on retrouve les lambda et les yield, si vous souhaitez plus d’informations sur ces derniers, je vous invite à vous rendre ici.

Les Conditions

If

Sûrement la condition la plus connue. en Ruby, voilà comment cela se présente :

if(a > b)
  "a superieur a b"
elsif(a < b)
  "a inferieur a b"
else
  "tous les autres cas"
end

Le mot clé end définit la fin du bloc if. On peut aussi écrire le if à la fin d’une instruction :

puts "J'ai plus de 18 ans" if(age > 18)

unless est le contraire du if, il faut le comprendre dans le sens “à moins que”. Notre exemple précédent donnerait : écrit “J’ai plus de 18 ans” à moins que la variable age soit inférieure à 18.

puts "J'ai plus de 18 ans" unless(age < 18)

Case

La condition case est l’équivalent du switch. Un exemple simple et vous aurez compris.

touche_pressee = "UP"
case touche_pressee
  when "UP" then puts "Haut"
  when "DOWN" then puts "Bas"
  else puts "Autre touche"
end

else est donc l’action par défaut à exécuter.

Les Boucles

Dernière partie de cette première partie de la syntaxe Ruby, les boucles. Rien de bien original, les boucles while prennent une forme tout à fait normale :

i = 0
while(i < 5)
  puts i
  i+=1
  break if(i == 2) # Sort de la boucle si i est égal à 2
end

Le break if est optionnel et permet de sortir de la boucle prématurément si la condition est remplie. Noter aussi l’utilisation de i+=1, en effet, en Ruby, on ne peut pas incrémenter un nombre avec un i++, on doit passer par la syntaxe i+=1.

De la même manière que le if possède un contraire (unless), while possède son contraire : until qui revient à dire : boucle jusqu’à ce que telle condition soit remplie.

Les boucles itératives sont du même style et se passent de commentaires pour leur forme la plus commune.

mon_tableau = %w(un deux trois)
for la_valeur in mon_tableau
  puts la_valeur
end

# affichera
# "un"
# "deux"
# "trois"

On parcours simplement le tableau et on affiche à chaque fois la valeur. La variable la_valeur est une référence sur l’élément actuel de la collection parcourue. Une autre manière d’arriver au même résultat serait d’utiliser la méthode each de l’Array qui permet d’exécuter un bloc de code pour chaque élément.

mon_tableau.each do |la_valeur|
  puts la_valeur
end

# Ou encore sur une ligne
mon_tableau.each{|la_valeur| puts la_valeur}

Voilà qui clôture ce chapitre qui a été bien plus long que je ne l’aurais imaginé. Beaucoup de choses essentielles à voir, certaines ont été omises, d’autres sûrement oubliées, n’hésiter pas à expérimenter déjà tout ça avec l’irb. On se rend compte que le Ruby est un langage facile à lire et à comprendre. Dans la prochaine partie, nous continuerons à apprendre la syntaxe du Ruby pour toute la partie orientée Objet.

Tags: , , , , , ,

6 commentaires pour “Ruby on Rails : Ruby et sa syntaxe part1”

  1. Boozdeuvash dit :

    In before xan

  2. Tarto dit :

    C’est un syntaxe un peu bizarre,
    Codant essentiellement en C/C++/Java c’est surprenant.
    Je me suis pas interessé au Ruby, mais j’ai lu ton article et il m’incite à lire le prochain.

    Mais c’est quoi cet opérateur unless ?

  3. Sylario dit :

    Ruby est vraiment un langage agréable a utiliser pour faire du script. Couplé avec gem qui est un apt-get/Yum dédié au bibliothèques ruby (et qui fonctionne sous windows) c’est génial.

  4. Sky dit :

    @Boozdeuvash: c’est à dire ? :)

    @Tarto: C’est simple, le if teste si une condition est vraie, unless le contraire, il teste si une condition est fausse.

    Imagine tu veux effectuer une boucle si x est égal à zéro, alors tu utilises un if. Maintenant, si tu veux effectuer un bloc de code pour toute valeur de x différente de zéro, alors tu peux utiliser unless. C’est surtout niveau lisibilité du code je pense puisqu’au final, on peut facilement se débrouiller avec un simple if.

  5. Tarto dit :

    @Sky

    J’avais compris, simplement je n’en voit pas l’intérêt.

  6. DjMerguez dit :

    Le unless ne sert qu’à rendre le code plus agréable à lire et écrire (sucre syntaxique).

Laisser un commentaire

Si vous avez un compte sur WeFrag, connectez-vous pour publier un commentaire.

Vous pouvez, entre autres, utiliser les tags XHTML suivant :
<a href="" title="">...</a>,<b>...</b>,<blockquote cite="">...</blockquote>,<code>...</code>,<i>...</i>