Découverte de Ruby - Partie I
Ruby est un langage interprété et objet. Ruby est sensible à la casse pour les mot-clés. Contrairement à Java, Ruby ne différencie pas objet et valeur primitive (entier...) et tout est objet.
Par exemple pour obtenir la valeur absolue de -1 :
-1.abs()
Pour afficher le résultat, la fonction puts est dispo :
puts -1.abs();
Pour exécuter votre code, récupérer l'interpreteur Ruby. Créer un ficher test1.rb (noter l'extension) et passer le à l'interpreteur simplement par "ruby test1.rb".
Résultat :
1
Tous les objets ont un identifiant obtenu par object_id et appartiennent à une classe.
a = 10
puts a.object_id
puts a.class
Fonctions
Le mot-clé def va servir à définir une fonction ruby. Des paramètres peuvent être passés. Inutile de typer vos arguments ou variables, Ruby déduit tout seul les bons types.
#Tests de fonction
def bonjour(qui)
puts "Bonjour #{qui}"
end
def aurevoir(qui)
return "Salut \n#{qui}"
end
#Appels
bonjour( "Moi" )
puts aurevoir( "Moi" )
La séquence #{Expr} sert à introduire une valeur dans une chaîne façon PHP. Le mot-clé return pour obtenir la valeur d'une fonction. #Pour un commentaire (no comment). A noter que les ";" en fin d'expression ne sont pas obligatoires (pour les nostalgiques), pareil pour les parenthèses lors de l'appel d'une fonction. Dans ce dernier cas elles sont conseillées (évolution du langage dans ce sens). Enfin, grand classique "\n" pour forcer un retour charriot.
Pour la sortie, puts peut aussi être remplaçé par printf avec un fonctionnement similaire à ce que l'on trouve en C. (passage s'arguments par %Type).
printf( "Very good job %s\n", "M." )
Tableaux
Les tableaux n'ont pas besoin d'être alloués, les tailles sont calculées dynamiquement. On a les tableaux indicés et les tableaux associatifs (type table de hachage).
#Tests des tableaux
monTab = [ "aa", "bb", 2008 ]
# 2008
puts monTab[ 0 ]
# nil
puts monTab[ 3 ]
# "ok"
monTab[3] = "ok"
puts monTab[ 3 ]
# Affiche le contenu
puts monTab
#Tableaux de chaîne
monTab2 = %w{ sympa ce système }
puts "#{monTab2[0]} #{monTab2[2]}"
#Tableaux associatifs
couleur = {
"bleu" => "blue",
"rouge" => "red",
"vert" => "green"
}
# blue
puts couleur[ 'bleu' ]
couleur[ 'orange' ] = 'orange'
puts couleur[ 'orange' ]
A noter qu'une tableau vide s'obtient par [] ou {}. Autre point concernant les chaînes entre simple quote ou double quotes, pareil au même. La propriété length est disponible pour connaître la taille d'un tableau.
Contrôle de flux
Les tests sont réalisés de manière classique par rapport à Java/C. Le mot-clé elsif est la contraction de else if.
a = 8
if ( a > 9 && a < 11 )
puts "a est entre 9 et 11"
else
puts "a est <= 9 ou >= 11"
end
if a == 8
puts "a = 8"
elsif
a == 9
puts "a = 9"
end
Pour les boucles, l'instruction while est à dispo :
while a > 0
a = a - 1
puts "#{a}"
puts ">5" if a > 5
end
A noter l'expression raccourcie puts ">5" if a > 5 équivallent à
if a > 5
puts ">5
end
Expressions régulières
Le format des expressions régulières est courant, il est défini entre /. La fonction sub sur une chaîne sert à faire une substitution, alors que gsub effectuera toutes les substitutions. L'opérateur =~ sert à verifier que le pattern /MonPattern/ à droite correspond à l'expression de gauche.
date= "070508"
#substitution
if date =~ /\d{6}/
puts "Date trouvée"
end
puts date.sub(/\d{2}/,"JJ")
Blocs d'instructions
Un bloc d'instructions est une expression entre { }, elle peut être passée à une fonction et invoqué par l'instruction yield. On se rapproche d'un langage fonctionnel car ce bloc d'instructions peut contenir des paramètres.
Commençons par un cas simple :
def rencontre
yield
puts "Au revoir"
end
rencontre {
puts "Bonjour"
puts "..."
}
Le bloc d'instruction ne peut être être passé comme un argument, c'est une sorte d'argument toujours accessible par yield (c'est une fonction qui représente ce bloc). Dans l'exemple ci-dessous on l'utilise avec un argument a.
def rencontre(a)
yield
puts "Au revoir n°#{a}"
end
rencontre(10) {
puts "Bonjour"
puts "..."
}
yield peut recevoir des arguments lui-même qui seront transmis au bloc d'instructions. Le bloc d'instructions déclare ces arguments entre | avec une virgule de séparation.
def rencontreBis(a)
yield(a)
end
rencontreBis(7) {
|numero|
puts "Bonjour n°#{numero}"
}
Un autre exemple si ce n'est pas clair :
def date(j,m,a)
yield( j,m,a )
end
date(7,5,2008) {
|jour,mois,annee|
puts "Bonjour la date est "
puts "#{jour}|#{mois}|#{annee}"
}
Où cela peut être utile ? Par exemple pour parcourir un tableau avec la fonction each.
tab = %w{ bonjour la vie est belle }
tab.each {
|mot|
puts "-->#{mot}"
}
Cette fonction utilise un bloc d'instructions auquelle elle passe l'élément du tableau au fur et à mesure. On parcourt ainsi la collection.
Autre exemple de fonction utilisant yield, times
10.times { puts "ok" }
>> Suite du tutorial