Ouvrages :

• Introduction aux design patterns
• Catalogue de design patterns
• Framework

• Bash
• Emacs Lisp
• Make

• UML 1.0
  

• Format XML
  

• CVS
• JDOC
• ANT
• EJB
• JMS
• Servlet
• JSP
• XSL
  

• Introduction aux design patterns
• Introduction à UML

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" }

Pour récupérer les sources

>> Suite du tutorial

Tips Java :

- Icônes multiples en swing
- datasource et jndi

Tips ASP :

- Accès BD avec MySql
- Algo de Levenshtein

Tests d'application :

- Nvu
- Demos

Tutoriaux :

- Ruby I
- Ruby II

Autre :

- Quelques photos