tuto important sur le code ruby pour faire vos propre code ou comprendre ceux des autre

Bon, ceci est un tutoriel qui vous permettra d'écrire et de lire un fichier qui déterminera des paramètres dans votre jeu, et qui permettra à un joueur de modifier certains paramètres.
Et cela en incluant une sécurité !


Dans ce tutoriel, je vous présente les principaux types utilisés en Ruby et l'essentiel à savoir sur les variables en Ruby.

I)Les principaux types rencontrés

1)Les entiers

Ils appartiennent à la classe Integer et font partie des valeurs numériques.



Portion de code:

nb = 2
var = -3
zero = 0





2) Les flottants

Ce sont les nombres décimaux de la classe Float. Attention à la virgule !



Portion de code:

pi = 3.14
nb = -5.68
zero = 0.0





3) Les booléens

Les deux seules valeurs possibles pour ces pseudo-variables sont true(vrai) et false(faux). Nous avons respectivement la classe
TrueClass pour true et FalseClass pour false.



Portion de code:

vrai = true
faux = false





4) Les chaines de caractères

Ce sont des chaines entre guillemets ou de simples caractères provenant de la célèbre classe String.



Portion de code:

msg = "Bonjour !"
ch = 'a'





5) Les intervalles

Pour définir un intervalle, on utilise la classe Range avec un borne de valeurs, avec ou sans exclusion.



Portion de code:

periode = 1939 .. 1945 # Inclusion de 1939 à 1945
periode = 1939 ... 1945 # Exclusion de 1945, avec de 1939 à 1944





6) Les tableaux

Un tableau est un ensemble de variables d'objets différents définis sous forme de liste. Il appartient à la classe Array.

En tout cas, vous devez savoir que toute liste ou tableau a un indice commençant par zéro.



Portion de code:

tab = [1,2.35,"quatre"]
tab[1] # 2.35





7) Les listes indexées

Une liste indexée est une liste associative associant un objet à partir d'un autre. La classe Hash gère ce type de listes.
Chaque élément associatif s'appelle une clé et s'associe à une valeur. L'index est l'indice commençant toujours par 0.



Portion de code:

liste = {1=>"un",2=>"deux",3=>"trois"}





Les objets invalides

La pseudo-variable nil sert à initialiser un objet non initialisé ou invalide. Elle appartient à la classe NilClass.



Portion de code:

rien = nil
nb_inconnu = nil





9) Les objets de manière générale

Comme vous avez pu le constater, chaque type est associé à son objet par instanciation. De manière générale, on définit un
type comme ceci :



Portion de code:

class Test
# Instructions
end

objet = Test.new





10) Les méthodes de conversion de types

Vous devez toutefois faire attention à certaines conversions.



Portion de code:

to_i # Conversion en entier
to_f # Conversion en flottant
to_s # Conversion en chaine de caractères
to_a # Conversion en tableau





Avec la pseudo-variable nil, voilà ce que ça nous donne :



Portion de code:

nil.to_i # 0
nil.to_f # 0.0
nil.to_s # ""
nil.to_a # []





II) Les opérations sur les variables

1) Les opérations mathématiques

Voici comment on définit des opérations mathématiques en général :



Portion de code:

a = a+1
a = a-2
a = a*4
a = a/3 # Jamais de division par zéro !
a = a%7 # Le modulo % renvoie le reste d'une division euclidienne





Je vous mets aussi la forme contractée :



Portion de code:

a += 1
a -= 2
a *= 4
a /= 3
a %= 7





2) La concaténation

Pour concaténer deux ou plusieurs chaines, on utilise la méthode + (qui est un opérateur mathématique, je sais !).



Portion de code:

"Bon"+"jour !" # "Bonjour !"





Ensuite, il est possible de multiplier un nombre de fois une chaine.


Portion de code:

"Go ! "*3 # "Go ! Go ! Go ! "
"Go !"*0 # Renvoie la chaine vide ""





III) Les booléens et les opérateurs logiques

Je donnerais des exemples concrets après avoir donné les formules logiques sur les booléens.

1) and(et)



Portion de code:

true and true # true
false and false # false
true and false # false

nb>=2 and nb<=5 # 2..5





2) or(ou)



Portion de code:

true or true
false or false
true or false

nb<=2 or nb>=15





3) not(non)



Portion de code:

not true # false
not false # true

not nb>=0 # nb<0





IV) Les différentes portées des variables

Je donnerais la portée et la syntaxe en fonction des variables.

1) Les variables locales

Elles ne s'utilisent que depuis là où elles sont définies.



Portion de code:

var = 0





2) Les variables d'instance ou attributs

Elles ne s'utilisent que dans la classe où elles sont définies et dans les classes dérivées.



Portion de code:

@var = 0





3) Les variables de classe

Ce sont des constantes de classe s'appliquant à l'ensemble des attributs d'une génération de classes.



Portion de code:

@@var = 0





4) Les variables globales

Ce sont des variables qui peuvent s'appeler et se rédéfinir de n'importe où. Elles sont à éviter autant que possible !



Portion de code:

$var = 0





5) Les constantes

Ce sont des variables gardant une valeur fixe.



Portion de code:

VAR = 0





V) Les instructions d'entrée-sortie

1) Pour afficher un message



Portion de code:

print "Bonjour !" # Sans saut de ligne
puts "Bonjour !" # Avec saut de ligne





2) Pour entrer une valeur



Portion de code:

print "Quel est votre age ?"
age = gets.chomp # Renvoyer automatiquement une chaine de caractère
puts "Vous avez #{age} ans."

print "Quel est votre pseudo ?"
age = gets
puts "Vous pseudo est "+pseudo.to_s # Si on doit convertir





Voilà, c'est tout pour les variables !




Difficulté : moyenne

A connaître : Les bases du ruby, le reste est expliqué, certains points de base sont aussi repris.

On apprend en plus des bases:
-l'utilité de la méthode "split" et de la méthode "gsub!" .
-Lire et écrire un fichier
-Gestion de l'erreur avec la structure begin...rescue...end

ETAPE 1 : Les paramètres et la syntaxe du fichier
---Paramètres à inclure---
Nous allons donc choisir quelques paramètres à déterminer.
Prenons, par exemple, deux variables de RPGMaker :
-$fontface qui détermine la police du texte
-$fontsize qui détermine la taille du texte

---Syntaxe du fichier---
Alors, je vais vous montrer une syntaxe simple, que vous utiliserez pour pouvoir lire le fichier, et en tirer des informations:





Portion de code:







Paramètre1 = valeur ;
P a r a m è t r e2 = A r ial_Blac k



Pourquoi est-ce écrit ça comme ça??
Parce que notre syntaxe ne prendra pas en compte les espaces donc :
P a r a m è t r e2 revient à écrire paramètre2.
Pourquoi ce tiret "_" entre Arial et Black?
Parce que ce tiret sera transformé par la suite par un espace,et si on colle Arial et Black, la police ne sera pas reconnue.
Ensuite, ce point virgule, c'est quoi??
(Bon, ouais, je me suis un peu inspiré du C++)
C'est pour séparer nos instructions, vous verrez comment par la suite.
Donc, voilà pour ça, la syntaxe est établie!
Maintenant, on va définir les paramètres par défaut du fichier ainsi que son nom.
Appelons le "Params.txt"
Et dedans, mettons:
Police = Arial;
Taille = 24

Remarques :
-la dernière instruction n'a pas besoin d'avoir un point virgule en sa fin.
-On crée le fichier une première fois pour tester, vous verrez pourquoi par la suite il se créera tout seul

ETAPE 2: Lecture du fichier
Là, les choses sérieuses commencent !
Nous devons tout d'abord ouvrir le fichier en lecture seule, puis, enregistrer son contenu dans une variable.
Procédons comme ceci:




Portion de code:







file = File.open("Params.txt", "r")
fichier = file #Vous verrez pourquoi après, c'est pour fermer
fichier = fichier.read



Mais qu'est ce que c'est ça??
Tout d'abord, on demande d'ouvrir le fichier "Params.txt", puis...
Ce "r" là, comme deuxième argument Késako ??
Ça veut dire qu'on l'ouvre en lecture seule on écrira pas dessus pour le moment, le pointeur se placera aussi au début du fichier.
Puis on demande à ce que la variable fichier prenne le contenu du document texte.

Alors, ça y est, on à tout dedans, mais comment on fait pour interpréter ça?????

Tout d'abord, on va enlever les espaces et transformer les tirets ("_") en espaces, comme cela:




Portion de code:







fichier.gsub!(" ", "")
fichier.gsub!("_", " ")



La méthode gsub! permet de remplacer une chaîne de caractères par une autre. Un exemple plus flagrant :




Portion de code:







fichier.gsub("oui", "true")



Ici, tous les "oui", seront transformés en "true"

Ceci fait on va séparer les instructions comme suit:




Portion de code:







fichier = fichier.split(";")



Késako ça aussi ??
Et bien, cela transforme la chaîne de caractère fichier, en un tableau, qui contient plusieurs chaînes de caractères : les parties séparées par les points virgules ! En fait, on a demandé de "couper" là où il y a un point virgule.
Donc, maintenant, pour avoir une vision:
fichier = ["Police = Arial", "Taille = 14"]
Voilà à quoi est égale notre variable fichier...
On peut rien faire avec ça non plus, il faut déjà mettre chaque partie du tableau dans une variable. Alors, on va faire:




Portion de code:







police = fichier[0]
taille = fichier[1]



Et voilà, on se retrouve avec 2 variables : police et fichier... police étant égale à la première partie du tableau et taille à la seconde...
Mais on peut encore rien faire avec ça...
On va donc séparer ce qui est d'un côté du "=", et ce qui est de l'autre côté et qui nous intéresse!
Alors on fait:




Portion de code:







police = police.split("=")
@police = police[1] #Pour qu'il soit reconnu plus tard
taille = taille.split("=")
@taille = taille[1].to_i #Pour qu'il soit reconnu plus tard




Une chose à noter : on convertit la chaîne de caractères "42" en un Integer (un entier) 42 grâce à la méthode to_i
Maintenant, on a les infos, ici on a:
police = "Arial"
taille = 24
Et pour la fin, on met cette ligne de code:




Portion de code:







file.close



Il ne nous reste plus qu'à mettre ça là où il faut.
C'est à dire, au commencement de tout... dans l'antre du script "main"!!!!
Donc, tout au début de main, mettez tout ce que je vous ai montré:




Portion de code:







file = File.open("Params.txt", "r")
fichier = file #Vous verrez pourquoi après, c'est pour fermer
fichier = fichier.read
fichier.gsub!(" ", "")
fichier.gsub!("_", " ")
fichier = fichier.split(";")
police = fichier[0]
taille = fichier[1]
police = police.split("=")
@police = police[1] #Pour qu'il soit reconnu plus tard
taille = taille.split("=")
@taille = taille[1].to_i #Pour qu'il soit reconnu plus tard
file.close



Et maintenant, pour appliquer ces modifs, nous restons dans "main" et nous changeons:
$fontface = "Arial"
$fontsize = 24
en




Portion de code:







$fontface = @police
$fontsize = @taille





ETAPE 3 : Gestion des erreurs
Alors, maintenant, imaginez un instant que le fichier soit supprimé, ou qu'il y ait une erreur à l'intérieur !
Catastrophe, le joueur est dans la mouise.
Donc, on va appliquer une gestion de l'erreur grâce à la technique
begin... rescue... end
A quoi ça sert?
Et bien, celà, si il y a une erreur, au lieu de vous afficher un message d'erreur et de fermer, fait que vous pouvez passer à la commande dans rescue pour rétablir la situation.
Nous allons donc foutre un begin en haut de notre code et à la fin un rescue (avant le begin de main).
A la suite du rescue, nous allons informer le joueur que le fichier "Params.txt" n'existe pas où est corrompu, avec un:




Portion de code:







print "Le fichier 'Params.txt' n'existe pas ou est corrompu.
Appuyez sur entrée pour créer le fichier"



Puis, on va créer le fichier en question, et écrire dedans, ou, s'il est erroné le remplacer par un nouveau.
Pour cela, nous allons faire:




Portion de code:







fichier = File.open("Params.txt", "w+")



Mais qu'est-ce que c'est que ce "w+"?
Ca veut dire qu'on l'ouvre en lecture/écriture, et qu'on écrase toutes les données à l'intérieur, et que s'il n'existe pas, on le crée.
Puis, on va écrire nos données par défaut dedans :




Portion de code:







fichier.write("Police=Arial;
Taille=24)



Et on referme le fichier pour enregistrer les modifications...




Portion de code:







file.close



Note: dans l'éditeur de script de XP, la deuxième ligne ne va pas apparaître violette comme si elle était entre guillemets, cependant, elle l'est en réalité. Dans l'éditeur de VX, ce bug a été corrigé

Maintenant, on va informer le joueur que le fichier a été créé :




Portion de code:







print "Le fichier 'Params.txt' a été créé avec succès!"



puis, fini le rescue, on met la touche finale!! :




Portion de code:







end



Donc, dans le rescue on a:




Portion de code:







rescue
print "Le fichier 'Params.txt' n'existe pas ou est corrompu.
Appuyez sur entrée pour créer le fichier"
fichier = File.open("Params.txt", "w+")
fichier.write("Police=Arial;
Taille=24)
file.close
print "Le fichier 'Params.txt' a été créé avec succès!"
@taille = 24
@police = "Arial" #Parce qu'il ne relit pas le fichier après
end



Et voilà, c'est fin prêt!!

ANNEXES
Voici un petit quelque chose que j'ai sortit de je sais pas où qui donne les "flags" et leur fonction:


Citation:

'r' Ouvre en lecture seule, et place le pointeur de fichier au début du fichier.
'r+' Ouvre en lecture et écriture, et place le pointeur de fichier au début du fichier.
'w' Ouvre en écriture seule ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
'w+' Ouvre en lecture et écriture ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
'a' Ouvre en écriture seule ; place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
'a+' Ouvre en lecture et écriture ; place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
'x' Créé et ouvre le fichier en lecture seule ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer. Ce mode est l'équivalent des options O_EXCL|O_CREAT pour l'appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2 et fonctionne uniquement avec des fichiers locaux.
'x+' Créé et ouvre le fichier en lecture et écriture ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer. Ce mode est l'équivalent des options O_EXCL|O_CREAT pour l'appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2, et fonctionne uniquement avec des fichiers locaux.





Voilà, c'est tout, si vous avez des questions à poser...

le plus complet

Ceci est le point de départ d’une série de tutoriels qui ont pour but de faire de vous des scripteurs capable de concevoir leurs propres scripts pour RMXP/VX.
Ils seront séparés en trois axes :
- Une partie d’apprentissage technique du Ruby avec exercice pratique.
- Une partie d’apprentissage technique du RGSS1/2 avec exercice pratique.
- Une partie d’entrainement pratique visant la conception et la programmation de script RMXP/VX.



Ruby / RGSS 2, qu’est-ce que c’est ?

Le Ruby est un langage de programmation qui n’a rien de spécifique à RPG maker.
Vous pouvez créer votre propre programme en utilisant le Ruby.
En exploitant l’analogie de la langue, le Ruby est la grammaire.
En la maitrisant, vous pouvez écrire ce que bon vous semble.
A ce niveau, écrire un script pour RPG maker consiste un peu à faire une dissertation sur le Positivisme sociologique.
La grammaire vous sera certes utile, mais il vous faudra quelque chose en plus.
C’est là qu’intervient le RGSS, qui vont fourni des outils techniques et un vocabulaire spécifique dont vous aurez bien besoin !!
RGSS signifie Ruby Game Scripting System.
On parle de RGSS pour RMXP et de RGSS2 pour RMVX car il y a quelques petites différences.
L’un n’allant pas sans l’autre, il est nécessaire de les étudier séparément avant de pouvoir les regrouper dans le cadre de la programmation du script.
Pour en savoir plus sur le Ruby : voir ceci !!

Au cours de ce cycle d’apprentissage, l’accent sera mis sur la pratique autant que sur la théorie.
Ce qui signifie qu’il vous faut un outil adapté à l’entrainement.
RMVX peut certes faire l’affaire mais s’avère somme toute peu approprié à un tel travail.
Lorsque je programme, il m’arrive de devoir tester des bouts de code, chose difficile à faire dans RM.
Pour cela, j’utilise ce logiciel : Scite.
Pour l’entrainement, je vous le conseille.



Comment utiliser Scite ?

Une fois installé, sauvegardez en utilisant l’extension .rb comme par exemple : « Test_ruby.rb ».
Pour tester un programme, il y a deux possibilités :
Appuyez sur F5 ou lancer le programme à partir du fichier.

Chapitre 1 : Constantes et variables

On commence avec quelque chose de très important là, quelque chose qui est au cœur de la programmation.
Chaque script que vous créerais comptera des dizaines de variables.
Commençons par les constantes !!

Les constantes :

Ca va vous paraitre obvie mais une constante, c’est quelque chose de constant, de fixe qui ne sera pas modifié par la suite.
Pour définir une constante en Ruby, il suffit de lui donner une valeur.



Code:
NUM = 1

Cela pourrait se traduite par « La constante NUM est égale à 1 ».
« NUM » est le nom qu’on lui donne.
Le fait que le nom commence par une majuscule nous indique qu’il s’agit d’une constante.
Toutes les constantes ont ce caractère en commun, la majuscule.
Attention : Num, NUm, NUM sont trois constantes différentes, elles ont des noms différents !!
Le «=» sert à donner à la constante la valeur qui suit, ici 1.
A partir de ce moment, utiliser un 1 ou utiliser NUM revient au même.
Ouvrons Scite et entrez ceci et faite F5 :



Code:
NUM = 5
puts NUM
puts 5
puts 5 * 5
puts NUM * 5

puts ?

puts est une fonction que nous utiliserons très souvent !!
Elle a pour effet d’afficher les informations qu’on lui donne en paramètre.
Ici les paramètres sont NUM, 5, 5 * 5 et NUM * 5

Si on observe la fenêtre de droite, on constate qu’afficher 5 ou NUM revient au même.
La multiplication 5 * 5 et NUM * 5 donne le même résultat.
Utiliser une constante peut simplifier nombre d’opération.
Imaginez de devoir taper à chaque fois 3.14159265358979 alors qu’un PI = 3.14159265358979 suivi d’une référence à la constante PI est beaucoup plus rapide.

Les variables :

Les variables se distinguent facilement des constantes, elles ne commencent pas par une majuscule !!
On leur attribue une valeur de la même manière que pour les constantes.
Ouvrez Scite, entrez ceci et faite F5 :



Code:
test = 1
puts test
test = 5
puts test
test = 123456789
puts test

La variable « test » reste, sa valeur change !!
De la même manière que pour les constantes, la variable et la valeur qu’elle contient se font écho.



Code:
test = 5
puts 5
puts test
puts 5 * 5
puts test * test

Il existe différentes sortes de variables.



Code:
puts $test
puts @test
puts test

Qu’obtient-on ?



nil ?

nil est l’équivalent du néant …
Ca peut être quelque chose qui n’existe pas ou la valeur de ce qui n’a pas de valeur.

Les variables globales « $test » et « @test » renvoient « nil » quand elles ne sont pas définies.
La variable local « test » tout comme les constantes entraine un message d’erreur quand elles ne sont pas définies.
Il faut donc toujours faire attention à bien définir les variables que l’on compte utiliser.
Il existe d’autres critères de distinction entre variable globale et locale que nous verrons plus tard.

Le nom d’une constante ou d’une variable est la façon dont on l’identifie.
Il faut donc le choisir avec attention !!
Les noms comme variable_un, variable_deux sont à éviter.
ID_ACTOR ou valeur_defense sont des noms que l’on identifiera facilement.

Quel est l’utilité de tout ça ?

Les constantes et les variables servent à stocker des informations.
Il peut s’agir d’un nombre qu’il soit entier (1 ou 14895363215) ou flottant (0.00000001 ou 3.14159265358979).
Il peut s’agir de chaines de caractères (des mots comme « azertyuiop » ou « ASHKA est le meilleur !! »).
Il peut s’agir de booléen (true ou false).
Il peut s’agir de … rien (« nil »).
Ou de tout un tas d’autre chose !!
Nous verrons en détail chaqu’une de ces possibilités par la suite.

Chapitre 2 : Classe et méthode :

Comment expliquer de manière simple ce qu’est une classe ou une méthode ?
Il y a une analogie très explicite !!
Une classe, c’est comme un programme.
Dans RMVX, la classe « Scene_Battle », c’est le programme qui gère les combats.
Une méthode, c’est un sous-programme.
Dans la classe « Scene_Battle », il y a une méthode « start_item_selection » qui s’occupe uniquement de faire apparaitre la fenêtre de sélection des objets.
Une classe comme une constante commence par une majuscule, une méthode comme une variable commence par une minuscule.
Comment les différencier ?
Simple !!



Code:
BATTLE = 1 # ceci est une constante
Battle # ceci est une variable
class Battle # ceci est une classe
def battle # ceci est une méthode
end
end

Les commentaires :

Tout ce qui se trouve après un # n’est pas considéré comme du code.
Vous pouvez vous en servir pour placer des commentaires dans vos scripts.
Si vous prévoyez plusieurs lignes de commentaire, il existe une solution plus pratique :



Code:
alpha = 1 # du code puis un commentaire
=begin
Tout
Ceci
Est
Un
Commentaire
=end
Beta = 2 # du code puis un commentaire

« class » suivi d’une majuscule indique une classe.
« def » suivi d’une minuscule indique une méthode.
Les classes comme les méthodes doivent impérativement se refermer par un « end ».



syntax error en dernière ligne ?

Les classes, les méthodes ainsi que les conditions et les boucles (que nous verrons ultérieurement) doivent impérativement se refermer par un « end ».
Si ce n’est pas le cas, le programme renverra un message d’erreur en indiquant la dernière ligne.
Ce type d’erreur est donc simple à diagnostiquer …
Une méthode (par exemple) n’est pas correctement fermée :
Soit elle n’est pas fermé (il manque un « end ») soit elle s’est refermé trop tôt (il y en a un en trop).
Simple à diagnostiquer mais parfois long à résoudre …
Le message indique là où l’erreur se manifeste, c’est-à-dire ici en dernière ligne mais le « end » manquant peut se trouver n’importe où dans la classe.
Pour éviter ce genre de problème, placez immédiatement le « end », et complétez ensuite le code.



Code:
class Test

end # class Test

Vous pouvez également utiliser les commentaires pour vous repérer !!

Regardez dans l’éditeur de script de RM, chaque script est en fait une classe spécifique.
Faite défiler rapidement tous les scripts de type Window_...
Chaque classe possède une méthode « initialize », étrange ?
La méthode « initialize » d’une classe est propre à cette classe et n’a aucun effet sur les autres classes.
C’est logique, chaque programme possède ses propres sous-programmes.

Au chapitre précédent, nous avons évoqué l’unes des différences entre les variables locales et globales, il est temps d’en voir une autre !!
Ouvrez Scite et entrez ceci :



Code:
class Test_Ruby
def affichage_un
return nombre
end
def affichage_deux
return nombre
end
end
test = Test_Ruby.new
puts test.affichage_un
puts test.affichage_deux

return ?

« return » est une autre fonction très utile !!
Elle sert à renvoyer ce qui est passé en paramètre.
Elle renvoi « nil » s’il n’y a pas de paramètre.
En plus de renvoyer un paramètre, « return » mets également fin à la « lecture » du code de la méthode où il se trouve.
Testez ce code :



Code:
def test
puts 1
puts 2
return
puts 3
puts 4
puts 5
end
puts test

=> 1, 2, nil …

Maintenant, donner un paramètre à « return » par exemple 111 et testez.
=> 1, 2, 111

Le « return » renvoi 111, le puts à comme paramètre se qui est renvoyer par la méthode « test », donc puts affiche 111.
Mais avant de s’avoir ce que renvoi la méthode, celle-ci affiche 1 et 2.
Les lignes se trouvant sous le « return » ne sont pas lu.

Déplacez le « return » à l’intérieur de la méthode et testez pour voir l'effet de "return" ...

Avant de tester, regardez la ligne 9 :



Code:
test = Test_Ruby.new

Au chapitre précédent, nous avons rapidement vu qu'une variable pouvait stocker des informations comme un nombre ou un mot.
Ici, nous sommes face à un cas différent.
La variable "test" stocke un nouvel objet de la classe "Test_Ruby".
Pour reprendre notre analogie, la variable "test" devient ainsi un programme "Test_Ruby".
En tant que "programme", elle a accès au sous-programme.
C'est ce que l'on voit aux lignes 10 et 11.
"test" et "Test_Ruby.new" sont équivalentes (souvenez vous du NUM * 5), on peut donc écrire :



Code:
Test_Ruby.new.affichage_un

Sachez que c'est possible même si ça ne se voit que très rarement ...

Bien, testons maintenant !!
Aïe !!! Un message d'erreur ...



undefined local variable or method `nombre'

Au chapitre 1, nous avons vu qu'une variable locale renvoyez un message d'erreur quand elle n'était pas défini ...
En voici la preuve.
Bon, placez ceci au dessus de "class Test_Ruby" (ligne 1) et testez :



Code:
nombre = 1

Hum, même problème ... Essayez en plaçant la définition de "nombre" juste sous "class Test_Ruby" ...
Encore, bon, placez la sous le "def affichage_un" ...
Même erreur mais plus au même endroit, de plus, le premier puts a fonctionné !!
L'explication est simple, une variable locale n'existe que dans le bloc où elle est définie.
Nos premiers essais se sont révélés infructueux car alors la méthode "affichage_un" ne connaissais pas de variable "nombre".
Là, elle la connaît, mais pas la méthode "affichage_deux".
La variable locale défini dans une méthode n'est connais que dans cette méthode, les autres ne peuvent pas la reconnaitre.
Une variable locale commence soit par une minuscule soit par un underscope (_nombre).

Essayez ceci maintenant :



Code:
class Test_Ruby
def affichage_un
return @nombre
end
def affichage_deux
return @nombre
end
end
test = Test_Ruby.new
puts test.affichage_un
puts test.affichage_deux

"nil" donc il ne s'agit plus d'une variable locale mais d'une variable globale.
Définissez @nombre = 1 en ligne 1 comme tout à l'heure.
Toujours "nil" ... Descendez la en ligne 2 (sous le "class Test_Ruby»).
Encore "nil" ... Bon, dans la méthode "affichage_un" maintenant ...
Tout fonctionne correctement, de plus, les deux méthodes semblent connaitre "@nombre" !!
Si une variable globale est définie dans une méthode, toutes les autres méthodes de la classe la reconnaitront.
Locale / globale : la différence est simple à comprendre !!

Essayez ceci maintenant :



Code:
class Test_Ruby
def affichage_un
return $nombre
end
def affichage_deux
return $nombre
end
end
test = Test_Ruby.new
puts test.affichage_un
puts test.affichage_deux

"nil" donc il s'agit d'une variable globale mais commençant par un "$" et non pas par "@".
Placez ceci ligne 1 :



Code:
$nombre = 1

Les variables commençant par un "$" sont reconnu partout dans le programme et ce quelque soit l'endroit où elles sont définies.

Nous en savons d'avantage sur les variables maintenant !!
Mais poursuivons l'étude des méthodes.

Testez ce code :



Code:
class Nombre
def creation(num = 0)
addition(num)
end
def addition(num)
num += 1
multiplication(num)
end
def multiplication(num)
num *= 2
affichage(num)
end
def affichage(num)
puts num
end
end
test = Nombre.new
test.creation(4)

On remarque plusieurs choses :
La méthode "creation" appelle la méthode "addition" qui appelle la méthode "multiplication" qui elle même appelle la méthode "affichage".
Comme nous sommes à l'intérieur de la classe (du programme) toutes les méthodes (sous-programmes) peuvent interagir directement entre elles.
(Pas besoin d'entrer "Nombre.new.addition", "addition" seul suffit, on est déjà dans "Nombre" !!)
Donc, la ligne "test.creation(4)" lance une sorte d'effet domino allant jusqu'a l'affichage de "10".

Pourquoi "10" ?
C'est simple, la méthode "creation" reçoit un paramètre en parenthèse (ici 4).
Elle le transmet à "addition" par l'intermédiaire de la variable locale "num".
Le "(num = 0)" indique que s'il n'y avait pas eu de paramètre de défini, la méthode aurait utilisé "0" comme paramètre par défaut.
"addition" fait sont travail puis transmet à "multiplication" et on poursuit jusque "affichage" (4 + 1 * 2 => 10).
Chaque méthode possède une variable locale "num" dont la valeur est passée en paramètre à chaque fois.

Remplacez le "4" par un autre nombre et testez, le transfert se fait sans problème.
Testez en supprimant le paramètre d'origine (supprimez le "(4)»).
Le paramètre par défaut de la méthode "creation" intervient (0 + 1 * 2 => 2).
Vous pouvez choisir le paramètre par défaut que vous voulez (essayez 1425).

Cet exemple a pour but de vous faire comprendre les paramètres des méthodes.
Bien évidement ici, une variable globale aurait pu remplacer les paramètres.
Mais ça n'est pas toujours possible, maitrisez cette technique est tres important !!

On en arrive maintenant au dernier point de ce chapitre !!



Code:
class Class_Parente
def affichage
puts "PAPA"
end
end
class Class_Heritante < Class_Parente
def affichage
super
puts "FISTON"
end
end
test = Class_Heritante.new
test.affichage

On voit ici plusieurs nouveautés :
Un "< Class_Parente" à coté du "class Class_Heritante" ligne 6 et un "super" ligne 8.
Niveau résultat aussi il y a des surprises !!
On appelle la méthode "affichage", espérant obtenir un beau "FISTON" et on obtient un "PAPA" en prime ...

Il est possible de faire en sorte qu'une classe hérite d'une autre classe.
C'est ce que l'on a fait à la ligne 6.
La classe parente peut donner un certain nombre d'éléments à la classe héritante, mais ceci n'est pas automatique.
C'est le "super" de la ligne 8 qui apporte les éléments de la classe parente.
Le "super" appelle la méthode "affichage" de la classe parente.
Placez le "super" sous le "puts" et testez.
On voit que la méthode "affichage" de la classe parente est appelé après l'exécution du "puts".

Testez ceci afin de savoir ce qui peut être hérité d'une classe parente :



Code:
class Class_Parente
def affichage
@alpha = 15
beta = 12
puts "PAPA"
end
def affichage_bis
puts "PAPA_BIS"
end
end
class Class_Heritante < Class_Parente
def affichage
super
affichage_bis
puts "FISTON"
puts @alpha
puts beta
end
end
test = Class_Heritante.new
test.affichage

On voit qu'il est possible pour la classe héritante d'utiliser les méthodes de la classe parente (la méthode "affichage_bis" ici).
Les variables globales définies dans la classes parentes sont accessibles depuis la classe héritante («@alpha" ici).
Mais ça n'est pas le cas des variables locales ...
Neutralisez le "super" en en faisant un commentaire (#) puis testez.
Pas de "PAPA", normal, on n'appelle plus la méthode de la classe parente.
Par contre, l'appel de la méthode "affichage_bis" fonctionne, normal, elle n'a pas besoin du "super" qui n'appelle que la méthode de la classe parente équivalente à celle où il est.
("affichage" appelle "affichage").


Le RGSS2 utilise énormément les méthodes et l'héritage, de manière beaucoup plus systématique que le RGSS d'ailleurs.
Et c'est l'une de ces forces !!
Il est important de bien comprendre les mécanismes qui ont été montré dans ce chapitre.

Chapitre 3 : Un peu de maths !!

Il n'est pas nécessaire d'être en Maths spé pour savoir scripter, cependant, il est clair qu'avoir une bonne maitrise des Mathématiques est un avantage !!
D'une certaine manière, les programmeurs sont des Pythagoriciens.
Enfin, avant d'en arriver à ce niveau, commençons par la base ...

Le Ruby utilise les symboles mathématiques de base :
(Addition, soustraction, division, multiplication, puissance)



Code:
puts 9 + 1
puts 11 - 5
puts 25 / 5
puts 5 * 5
puts 5 ** 2

Moins courant, le modulo renvoi le reste d'une division :
(Souvenez vous de l'école : Combien de fois y a-t'il 2 dans 5 => 2 fois mais il reste 1)



Code:
puts 5 % 2

On peut également avoir recourt à des variables, mais celle ci doivent être défini.
C'est évidement le cas des variables locales qui renvoi un message d'erreur quand elles ne sont pas définies.
Mais c'est aussi le cas des variables globales, il n'est pas possible d'additionner 5 et "nil" ...



Code:
test = 14
puts test
test = test + 19
puts test
test = test - 8
puts test
test = test / 5
puts test
test = test * 10
puts test
test = test % 3
puts test
test = test ** 3
puts test

En fait, vous ne rencontrerais pas très souvent cela mais plus probablement la forme contracté, beaucoup plus pratique :



Code:
test = 14
puts test
test += 19
puts test
test -= 8
puts test
test /= 5
puts test
test *= 10
puts test
test %= 3
puts test
test **= 3
puts test

Evidement, il est possible de faire des calculs plus complexes ...
Il existe même un module spécifique regroupant des fonctions mathématiques plus complexes !!



Qu'est-ce qu'un module ?

Un module est quelque chose de comparable à une classe.
Mais à la différence de celle ci, le module est plus un programme de référence qu'un programme d'exécution.
C'est généralement là que sont définies les constantes.
Mais il peut également y avoir des classes ou des méthodes !!

Regardez ceci :



Code:
module Mathematique # remarquez la majuscule !!
PI = 3.14159265358979
def self.affiche_pi
puts PI
end
end

class Test_Ruby
def affichage
puts Mathematique::PI
Mathematique.affiche_pi
end
end
test = Test_Ruby.new
test.affichage

On remarque tout d'abord qu'un module commence par une majuscule, comme les classes.
Mais la définition des méthodes est différente.
Le "self" ligne 3 fait référence au module "Mathematique".
Cela permet de définir la méthode "affiche_pi" du module "Mathematique".

A la ligne 10, on voit comment est appelé la constante PI du module "Mathematique" depuis une autre classe.
Même chose ligne 11 avec l'appel de la méthode "affiche_pi".
Grace à ces commandes, le module peut être "consulté" depuis n'importe quel classe/méthode du programme.

Le module "Mathematique" présenté ci-dessus est purement fictif (écrit juste pour vous expliquer) ...
Il existe déjà le module "Math", beaucoup plus complet !!

Voici quelques unes des fonctions mathématiques qu'il reprend :



Code:
puts Math.cos(10) # cosinus
puts Math.sin(10) # sinus
puts Math.tan(10) # tangente
puts Math.exp(10) # exponentielle
puts Math.log(10) # logarithme
puts Math.sqrt(25) # racine carré
puts Math::PI # constante PI

Jusqu'a maintenant, je n'ai jamais eu à utiliser ça mais sait-on jamais !!
Il n'y a pas grand chose à voir, cependant, nous utiliserons très souvent ces outils mathématiques par la suite.

Chapitre 4 : Les conditions :

En Ruby, il existe plusieurs façons de faire des conditions.
Elles sont toutes plus ou moins équivalente, vos préférences ou la façon dont est construit votre code vous déterminerons celles que vous utiliserais.

Avant de les voir, il convient d'étudier le module "Comparable".
Il est composé de fonction permettant de comparer deux objets en renvoyant un booléen.
On obtiendra "true" si le résultat est vrai et "false" s'il est faux.



Code:
obj_un = 15
obj_deux = 25
puts obj_un < obj_deux
puts obj_un > obj_deux
puts obj_un >= obj_deux
puts obj_un <= obj_deux
puts obj_un == obj_deux

Ligne 3 : On obtient "true" si obj_un "est strictement inférieur à" obj_deux et "false" dans le cas contraire.
Ligne 4 : On obtient "true" si obj_un "est strictement supérieur à" obj_deux et "false" dans le cas contraire.
Ligne 5 : On obtient "true" si obj_un "est supérieur ou égal à" obj_deux et "false" dans le cas contraire.
Ligne 6 : On obtient "true" si obj_un "est inférieur ou égal à" obj_deux et "false" dans le cas contraire.
Ligne 7 : On obtient "true" si obj_un "est strictement égal à" obj_deux et "false" dans le cas contraire.
(Attention à ne pas confondre le symbole "égale" (= ) et le symbole "est strictement égal à" (== ) !!)

Il existe une autre méthode dans le module "Comparable" :



Code:
puts 3.between?(1, 5)

Ceci renvoi "true" si la valeur principal (ici 3, mais on aurait pu utiliser une variable) est comprise entre les deux paramètres (bornes incluses).
3 est bien compris entre 1 et 5 => on obtient "true".
A noter : Une méthode dont le nom fini par un "?" indique qu'elle renvoi un booléen.
Ca n'est pas une obligation, plutôt un code généralement admis (et utilisé).

Il existe un autre moyen de comparaison très utilisé mais qui ne fait pas partie du module "Comparable" :



Code:
obj_un = 15
obj_deux = 25
puts obj_un != obj_deux

On obtiendra "true" si obj_un "est différent de" obj_deux et "false" s'ils sont égaux.

Comme vous pouvez l'imaginer, ces comparaisons sont très souvent utilisées dans les conditions !!

"if" et "unless"

Celle que l'on utilise le plus , c'est "if".
Voila comment construire un bloc :



Code:
obj = -5
if obj < 0
puts "Négatif !!"
elsif obj > 0
puts "Positif !!"
else
puts "ZERO !!"
end

La condition forme un bloc, elle doit donc être refermée par un "end" comme les classes ou les méthodes !!
Les éléments "elsif" et "else" sont facultatif, seul le "if" et le "end" sont obligatoires.
Si la comparaison du "if" (ligne 2) est "true", ces instructions seront exécutées ce qui mettra fin au bloc.
Sinon, on passe à la condition suivante et ainsi de suite jusqu'a ce qu'une condition soit vrai ou que l'on arrive à la fin du bloc.
"if" et "elsif" sont déterminés, alors que "else" est générale.
"else" reprend tout ce qui n'est pas déterminé.



Code:
obj = -5
if obj == 0
puts "ZERO !!"
else
puts obj
end

Dans tout les cas où la première condition n'est pas vrai, le "else" s'exécutera, donc que obj soit égal à -15 ou 4598 ou toutes les autres possibilités.
Il faut donc bien réfléchir pour savoir quelles conditions écrire et si utiliser "else" est utile ou pas.
On peut utiliser le "if" sous des formes différentes :
(Chaque bloc est séparé par un #)



Code:
num = 6
obj = num.between?(1,5)
#
if obj then puts "vrai" else puts "faux" end
#
if obj
then puts "vrai"
else puts "faux"
end
#
puts "vrai" if obj
#
puts "faux" if obj == false
#

La variable "obj" contient un booléen, la ligne 6 est la contraction de :



Code:
if obj == true

Ceci n'est possible que pour "true" et non "false" (voyez la ligne 13).

Parfois, une seule condition ne suffit pas, il est possible d'en associer plusieurs :



Code:
num = 6
obj = num.between?(1,5)
if obj and num < 3
puts "Inf. à 3"
elsif obj && num > 3
puts "Sup. à 3"
elsif obj
puts "3"
else
puts "Pas entre 1 et 5"
end

A la ligne 3, on associe deux conditions, celle si ne s'exécutera que si obj est "true" ET que num est inferieur à 3.
C'est-à-dire s'exécute si tous les éléments sont "true".
"and" peut aussi s'écrire "&&" (voir ligne 5).



Code:
num = 5
if num == 1 or num == 3 || num == 5
puts "Impair"
else puts "Pair" end

On peut traduire la ligne 1 par "si num est égale à 1 ou 3 ou 5 ...".
Le "or" et le symbole "||" revient au même.
Ici, la condition est exécutée si au moins un des éléments est "true".

Il existe une autre forme de condition qui est en fait l'inverse du "if", c'est le "unless".



Code:
num = false
if num
puts "vrai"
end
puts "---"
unless num
puts "faux"
end
puts "---"
if ! num
puts "faux"
end

La condition ligne 2 ne s'exécutera que si num est "true".
La condition ligne 6 ne s'exécutera pas si num est "true", mais elle s'exécutera dans le cas contraire.
"unless" signifie "sauf si", la condition s'exécute automatiquement sauf si elle est "true".
Ligne 10, on constate que le "!" inverse l'exécution de la condition "if".

"case"

L'opérateur "case" est assez différent de "if" ou "unless".
Voici comment l'utiliser :



Code:
num = rand(10)
case num
when 1,3,5,7,9
puts "Impair"
when 2,4,6,8
puts "Paire"
else
puts 0
end

rand(10) ?

La méthode "rand" consiste un peu en un lancer de dé.
Elle renvoi un nombre aléatoire compris entre 0 et le nombre indiqué entre paramètre (paramètre exclut).
"rand(10)" peut donc renvoyer au hasard 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Ligne 2, on voit l'opérateur "case" avec en paramètre ce qu'il va "analyser".
Il compare alors la valeur du paramètre avec chaque possibilité qu'on lui a programmé.
Dès que l'une de ces possibilités est "true", la commande s'exécute et le bloc prends fin (notez le "end" final une fois de plus).
La ligne 3 correspond à ceci si on avait utilisé un "if" :



Code:
if num == 1 or num == 3 or num == 5 or num == 7 or num == 9

Dans ce genre de situation, "case" est beaucoup plus adapté que "if" !!

Les conditions ternaires :

En voici un exemple :



Code:
num = 5
num > 0 ? (puts "Positif") : (puts "Négatif")

Si la condition (placé avant le "?") est "true", le programme exécute la première commande (celle juste après le "?").
Si elle est fausse, le programme exécutera la seconde commande, celle juste après le ":" ...
Ceci est une autre façon de programmer :



Code:
if num > 0 then puts "Positif" else puts "Négatif" end

C'est à vous, selon les cas et vos préférences de choisir la condition la plus approprié !!
C'est tout pour ce chapitre !!

Les boucles :

Le mot "boucle" est un terme générique désignant une fonction qui s'exécutera plusieurs fois.
C'est là un des gros avantages du Ruby face à la programmation événementiel de RM.
Les boucles sont beaucoup plus pratiques en Ruby, vous en utiliserais très très souvent !!
Il en existe plusieurs, ayant chaqu'une les spécificités.

"for ... in" :

Il s'agit d'une fonction qui s'exécutera une fois pour chaque élément de l'ensemble qu'on lui associe.



Code:
for n in 0..9
puts n
end

Une boucle constitue un bloc, donc attention à ne pas oublier le "end" final !!
Regardez la dernière partie de la ligne 1 ("0..9").
Cette commande va créer un intervalle.
Le départ est ici 0, le terme est ici 9.
(A noter : "0..9" signifie que les bornes sont incluses dans l'intervalle tandis que "0...9" exclura la borne finale de l'intervalle !!)
La boucle va tour à tour affecter la variable locale "n" avec un élément de l'intervalle puis exécuter les actions programmées.
Il est possible d'utiliser des variables comme borne pour l'intervalle.
Et les boucles sont très souvent utilisées avec une condition.



Code:
min = -1
max = 10
for n in (min + 1)...max
if (n % 2) == 0
puts "Paire"
elsif (n % 2) == 1
puts "Impair"
end
end

"while" :

"while" signifie "tant que".
Cette fonction est associée à une condition et elle s'exécutera tant que cette condition retournera un "true".



Code:
num = 0
while num < 10
puts num
num += 1
end

Il s'agit d'un bloc donc un "end" pour refermer !!
(A force de le répéter, vous ne l'oublierais pas !!)

La condition peut être "true" pendant très longtemps, le bloc risque alors de ne pas s'arrêter.
Il est possible d'inclure un système de sortie.
(C’est possible pour chaque boucle, même si le "for ... in" est limité à un ensemble, ça peut s'avérer utile !!)



Code:
num = 0
while num < 1000000000000
puts num
num += 1
break if num == 10
end

"break" est l'instruction de sortie.
S'il n'est pas associé à une condition, il s'exécutera à la première lecture.
Ici, il s'exécute dès que num est égale à 10.
L'endroit où le "break" est placé peu avoir de l'importance.
Tel qu'il est placé, le dernier affichage est "9".
Si vous le placez avant le "num += 1", le dernier affichage sera "10".

"until" :

"until" signifie "jusqu'a ce que"
Cette fonction est également associée à une condition, mais elle s'exécutera jusqu'a ce que la condition soit "true".
(Il s'agit de la fonction inverse d'un "while" ...)



Code:
num = 0
until num == 100
puts num
num += 1
break if num == 10
end

Il est souvent pratique d'utiliser "break" surtout si on ne sait pas quand la condition sera "true" ...

"loop" :

Cette boucle est infini, l'utilisation d'un "break" est donc nécessaire pour en sortir !!



Code:
num = 0
loop do
puts num
num += 1
num = 0 if num >= 10
break if rand(10) == num
end

Testez-le plusieurs fois !!

Voila ce qu'il est important de savoir sur les boucles.
C'est également la fin de la première partie de ce tutoriel.
Les fonctions que nous avons vues jusqu’ici sont la base du Ruby.

La suite du tutoriel consistera à examiner les spécificités des différents objets existant en Ruby.
C'est-à-dire les différents types d'informations pouvant être stockées dans une variable ainsi que les méthodes qui s'y rattachent.
Nous n'examinerons pas toutes les méthodes de chaque classe mais seulement les plus utilisées.

La classe "Object" :

La classe "Object" est une superclasse dont toutes les autres classes héritent.
Toutes les classes que nous étudierons par la suite peuvent utiliser les méthodes de la classe "Object".
Parmi les méthodes les plus utiles, on trouve le symbole de comparaison "==".
Il existe d'autres méthodes qui pourront vous être utile :



Code:
@num = 12
puts @num.nil?
puts @num.to_s
puts @num.is_a?(Object)
puts @num.is_a?(String)
puts @num.is_a?(Numeric)

La méthode "nil?" est assez explicite ...
Elle renvoi un booléen (indiqué par le "?») si l'objet est "nil".
@num est défini et a une valeur (12) donc "nil?" renvoi "false".

La méthode "to_s" sert à convertir un objet quelconque en objet de la classe "String".
Nous étudierons en détails cette classe par la suite.
Pour l'instant, retenez juste l'existante de cette méthode qui s'avère très utile.
En effet, RM n'affiche que des objets de la classe "String" ...
Convertir un objet pour pouvoir l'afficher est quelque chose que vous ferais très souvent !!

La méthode "is_a?" renvoi un booléen.
Elle sert à vérifier à quelle classe appartient l'objet examiné.
Ici, @num est un "Object" (évidement ...)
On voit qu'il n'est pas un objet de la classe "String" (d’où l'utilité de la méthode "to_s»)
Il s'agit d'un objet de la classe "Numeric".
Classe que nous allons étudier immédiatement !!

La classe "Numeric" :

Sans le savoir, vous avez au cours de ce tutoriel déjà utilisé des dizaines d'objets de cette classe !!
En effet, un objet de la classe "Numeric" est ... un nombre.
Le module "Comparable" est inclut dans la classe "Numeric".
Vous ne le saviez pas mais ça ne vous a pas empêché de l'utiliser dans le chapitre sur les conditions ...
Voici les principales méthodes de cette classe :



Code:
puts +1
puts -1
puts -15.9.abs
puts 0.50.ceil
puts 0.50.floor
puts 0.50.round
puts 15.integer?

Et oui, le "+" et "-" sont des méthodes !!
Elles servent à définir un nombre positif ou négatif.

"abs" renvoi la valeur absolue de l'objet.

"ceil" renvoi le nombre entier le plus proche étant supérieur (arrondi supérieur).
"floor" renvoi le nombre entier le plus proche étant inferieur (arrondi inferieur).
"round" renvoi l'entier le plus proche.
"integer?" renvoi un booléen vérifiant si le nombre est un entier.

En effet, la classe "Numeric" est la classe parente de deux autres classes.
La classe "Integer" qui correspond à l’entier (-148 ou 48952).
La classe "Float" qui correspond au flottant (0.000001 ou 3.14159265358979).
L'étude de cette dernière n'apporte pas grand chose, nous nous concentrerons sur les entiers.

La classe "Integer" :

Tout d'abord, voici comment créer un objet de cette classe :



Code:
num = Integer(14)
# ou
num = 14

Bien évidement, la seconde forme est la plus fréquemment utilisée ...
Il est tout aussi évidement que les entiers peuvent "utiliser" les opérateurs mathématiques que nous avons vu au chapitre 3 !!
Les objets de cette classe ont leurs propres méthodes :



Code:
puts 10.to_f, ''

5.times do puts "Yo !!" end; puts ""

0.step(10, 2) {| i | puts i.to_s + " est un nombre pair." }
puts ""

10.downto(0) {| i |
puts i
puts "..."
}
puts "BOUM !!"
puts ""

0.upto(10) {| i |
if (i % 2) == 1
puts i.to_s + " est un nombre impair."
end
}
puts ''

Pfuh, il y en a des choses à expliquer là !!

La méthode "to_f" sert à convertir un entier en flottant.
On voit aussi qu'il est possible de passer plusieurs paramètres au "puts" grâce à une virgule.

La méthode "times" va créer une boucle qui s'exécutera un certain nombre de fois.
(«5.times" donc 5 fois)
Il peut aussi s'agir d'une variable contenant un entier.
Le symbole ";" permet d'entrer plusieurs commandes sur la même ligne.
Ce bloc aurait pu s'écrire :



Code:
5.times do
puts "Yo !!"
end
puts ""

Les trois méthodes suivantes vont créer un bloc (entre accolades).
Ce bloc s'exécutera pour chaque élément "i" de l'ensemble.

"step" sert à établir des paliers.
Le premier nombre indique le point de départ.
En paramètre, nous avons en premier le point d'arrivé et en second, la "taille" du pallier.
Ceci permet de définir un ensemble, le bloc sera ensuite exécuté pour chaque élément de l'ensemble.

"downto" crée un décompte.
Le premier nombre est le point de départ, le paramètre indique le point d'arrivé.
Le bloc peut être écrit sur plusieurs lignes pour simplifier la lecture.
Dans ce type de bloc, c'est l'accolade qui détermine le bloc et non pas un "end".
Si le "puts "BOUM !!" était placé dans le bloc, il se serait affiché pour chaque élément.
Ici, il ne s'exécute qu'a la fin du bloc.

"upto" est l'inverse de "downto".
Au lieu d'être décroissant, l'évolution est ici croissante.

Voila, vous en savez désormais beaucoup sur les objets de la classe "Numeric" !!
Je vous propose un petit exercice, histoire de vous entrainer.
Créez une méthode "factorielle" dans la classe "Integer".
La factorielle est un outil mathématique que l'on utilise notamment dans les probabilités.
La factorielle de 5, c'est 5! = 5 * 4 * 3 * 2 * 1 = 120
Complétez ceci :



Code:
class Integer < Numeric
def facto
# A compléter
return result
end
end

puts 5.facto

Pour faire référence à l'objet de base, utilisez "self".
("self" désigne l'objet de la classe)
Dans "5.facto", "self" désigne 5
Dans "10.facto", "self" désignera 10 ...

Bon, comme c'est trop simple, et vu le nombre de fonction pouvant être utilisé pour obtenir ce résultat, je voudrais que vous essayais au moins trois codes différents.
(Trois codes vraiment différents utilisant des fonctions différentes ...)

La classe "String" :

Les objets de la classe "String" sont ce qu'on appelle des chaines de caractères.
Voici comment les créer :



Code:
aa = String.new('alpha')
bb = String("beta")
cc = "gamma"
puts aa, bb, cc

La troisième technique est la plus utilisé ...
Tout ce qui se trouve entre "" ou entre '' est une chaine de caractère.
D'ailleurs, Scite et RMVX les matérialisent d'une couleur spécifique.
(Jetez un œil au module Vocab de RMVX ...)

Cette classe possède de nombreuse méthode, en voici quelques unes des plus courantes :



Code:
debut = "ASH"
fin = "KA"

tout = debut + fin
puts tout

debut << fin
puts debut

repete = (debut + " ") * 5
puts repete

puts "Hello".concat(" you") << " !!"

Ligne 4, on additionne les deux objets dans un troisième.
Ceci ne modifie ni "debut" ni "fin".

Ligne 7, "debut" est "complété" avec "fin".
"debut" est ainsi modifié mais pas "fin".

Ligne 10, la chaine est multiplié par 5, donc elle est répété 5 fois bout à bout.
Si j'avais utilisé "debut * 5" simplement, tout aurais été collé.

La méthode "concat" a le même effet que le symbole "<<".
La chaine à ajouter est passé en paramètre.

Le module "Comparable" est automatiquement inclut dans la classe "String" :



Code:
num = rand(5) + 1
if num.to_s == '1'
puts "Je n'ai que " + num.to_s + " bonbon ..."
else
puts "J'ai #{num} bonbons !!"
end

Evidement, une chaine de caractère peut contenir des nombres.
Mais il s'agit d'un objet "String" pas "Integer".
Les lignes 3 et 5 montrent deux façons différentes d'obtenir la même chose.
(La seconde ne nécessite pas l'utilisation de la méthode "to_s")

Il reste beaucoup de méthode à voir dans cette classe :



Code:
text = "abcdefghijklmnopqrstuvwxyz"
taille = text.length
puts taille

for i in 0..(taille - 1)
puts text[i]
end

puts text[5, 1]

puts text[1..5]

text[0] = "w"
puts text

text[5, 5] = "azerty"
puts text

text[11..16] = "wxcvbn"
puts text

puts text.include?("g")

puts text.delete("w")

un = "monsieur"
deux = "ashka"
puts "Bonjour " + un + " " + deux
puts "Non, il faut dire :"
puts "Bonjour " + un.capitalize + " " + deux.upcase + " !!"
excuse = "DéSOLé ..."
puts excuse.downcase.capitalize

test = "MAJUSCULE minuscule"
puts test.swapcase

Ligne 2, la méthode "length" renvoi un Integer qui correspond à la "taille" de la chaine.
La méthode "size" a le même effet.

Chaque caractère possède un code.
Ligne 6, les crochets indique que l'on regarde un caractère précis de cette chaine.
"puts" n'affiche pas ici le caractère pas le code qui lui correspond.
Le premier caractère correspond au 0 et non au 1 !!

Ligne 9, ici on crée un ensemble à partir d'une chaine.
Les paramètres entre crochets correspond au point de départ et à la durée.
"puts" peut donc afficher tous les caractères de cet ensemble.

A la ligne 11, on a la même chose mais avec un intervalle au lieu des deux paramètres.

Les trois groupes suivant ont un "=" donc vont servir à affecter une nouvelle valeur soit :
- En remplaçant un caractère de la chaine (Cf. ligne 13).
- En remplaçant plusieurs caractères de la chaine.
(Ligne 16 avec un ensemble et ligne 19 avec un intervalle.)

La méthode "include?" renvoi un booléen, elle sert à vérifier la présence d'un ou plusieurs caractères dans la chaine.
(Les caractères à chercher sont passé en paramètres, ici le "g".

La méthode "delete" va renvoyer une nouvelle chaine et supprimer toutes les apparitions du paramètre de la chaine d'origine.
La methode "delete!" renvoi la chaine d'origine modifié ou "nil" si aucune modification n'est faite.
Attention un "w" et un "W" sont deux caractères différents !!

La méthode "capitalize" renvoi une nouvelle chaine mais commençant par une majuscule.
La methode "capitalize!" renvoi la chaine d'origine modifié ou renvoi "nil" si aucune modification n'est faite.
La méthode "upcase" renvoi aussi une nouvelle chaine, mais cette fois, tous les caractères deviennent des majuscules.
Le maethode "upcase!" renvoi la chaine d'origine modifié ou renvoi "nil" si aucune modification n'est faite.
La méthode "downcase" fait l'inverse (renvoi une nouvelle chaine et remplace les majuscules par des minuscules).
De la même maniere, "downcase!" renvoi la chaine d'origine modifié ou renvoi "nil" si aucune modification n'est faite.
Il est possible d'utiliser plusieurs méthodes à la suite, on n'est pas obligé de revenir à la ligne.
Mais si une méthode modifie la chaine, la méthode suivante sera basé sur la nouvelle chaine, pas sur celle d'origine !!
La méthode "swapcase" renvoi une nouvelle chaine et transforme les majuscules en minuscules et les minuscules en majuscules.
( Il existe aussi une methode "swapcase!" )

Si vous remplacez les lignes 16 et 17 par ceci :



Code:
text[5, 5] = nil
puts text

Vous obtiendrais un message d'erreur car il n'est pas possible de remplacer un morceau de chaine par "nil".
Cependant, regardez ceci :



Code:
text[5, 5] = ''
puts text

Remplacer l'ensemble par une chaine vide est possible !!
Il existe une autre façon de modifier une chaine :



Code:
num = "0123789"
num.insert(4, "456")
puts num

puts num.to_i * 2

puts num.to_f

La méthode "insert" sert à insérer une chaine à l'intérieure d'une autre chaine.
Le premier paramètre indique la position où va s'intercaler la nouvelle portion de chaine (second paramètre).
Je rappelle que le premier caractère à la position 0 !!

La méthode "to_i" sert à convertir une chaine en Integer alors que la méthode "to_f" sert à convertir une chaine en flottant.

Il reste encore de nombreuses méthodes à voir :



Code:
puts "azerty" + "azerty"

puts "azerty\n" + "azerty"

puts "az\nerty\n".chomp + "azerty"

test = "azertyuiopqsdfghjklmwxcvbn"
puts test
while test != "azerty"
test = test.chop
puts test
end
puts test

Le symbole "\n" correspond au retour à la ligne.
Ligne 1, les deux chaines sont affichées cote-à-cote.
Ligne 3, il y a un retour à la ligne, les deux chaines seront sur des lignes différentes.

Ligne 5, la méthode "chomp" a pour effet de renvoyer une nouvelle chaine en supprimant le symbole "\n" en fin de chaine.
La methode "chomp!" renvoi la chaine d'origine modifié ou "nil" si aucune modification n'est faite.

La méthode "chop" retourne une nouvelle chaine après avoir supprimé le dernier caractère de la chaine.
( Il existe une methode "chop!" renvoyant la chaine d'origine modifié ou "nil" si la chaine est déjà vide )



Code:
test = "azazazazzazaz"
puts test.size
puts test.count("a")
puts test.delete("z").size
puts test.delete("a").length
puts test
puts test.empty?

test = ""
puts test.empty?
puts test.nil?

test = "azertyuiop"
puts test.index("y")
puts test.index("tyu")
puts test.index("w")

test = "kayak"
puts test.reverse
test = "0123456789"
puts test.reverse

test = "azertyuiop"
puts test.slice(3, 3)
puts test.slice(0..5)

La méthode "count" retourne un Integer correspond au nombre de fois où le paramètre apparait dans la chaine.

La méthode "empty?" renvoi un booléen, elle sert à verifier si la chaine est vide ou pas.
(Rappel : une chaine vide est différente de "nil")

La méthode "index" permet d'obtenir, sous la forme d'un Integer, la position dans la chaine du caractère passé en paramètre.
C'est également possible si le paramètre est une chaine.
"nil" indique que le caractère demandé n'est pas présent dans la chaine.

La méthode "reverse" sert à inverser une chaine de caractère en renvoyant une nouvelle chaine modifié.
Il existe une methode "reverse!".
(Bon, le premier exemple n'est pas très parlant ... regardez surtout le deuxième ...)

La méthode "slice" permet de découper une chaine de caractère.
Il existe une methode "slice!"
On peut passer en paramètre un ensemble ou un intervalle.
(Rappel : les paramètres pour l'ensemble sont point de départ et durée)

Bon, on attaque maintenant la dernière partie, et non la moindre ...



Code:
test = "J'aime pas les frites ..."
test = test.gsub(/pas/, 'bien')
test = test.gsub(/[.]/, "!")
puts test

test ="azazazazazazaza"
puts test.gsub(/./, " - ")
puts test.gsub(/a/) {|s| s + "r " }
puts test.gsub(/a/, "")
puts test.gsub(/[az]/, rand(10).to_s)
puts test.gsub(/[az]/, ".")

puts ''

test = "J'aime pas les frites ..."
test = test.sub(/pas/, 'bien')
test = test.sub(/[.]/, "!")
puts test

test ="azazazazazazaza"
puts test.sub(/./, " - ")
puts test.sub(/a/) {|s| s + "r " }
puts test.sub(/a/, "")
puts test.sub(/[az]/, rand(10).to_s)
puts test.sub(/[az]/, ".")

Les méthodes "gsub" et "sub" servent à scanner la chaine de caractère et à exécuter une certaine action si un ou plusieurs caractères prédéterminés sont rencontrés.
Il existe aussi des methodes "gsub!" et "sub!".
La différence entre les deux est que la méthode "sub" n'agira que sur le premier caractère souhaité.
"gsub" agira sur tous les caractères souhaités dans la chaine.
Dans les deux cas, le premier paramètre est le ou les caractères à rechercher (placé entre "/"), le second est le caractère de remplacement.
On peut aussi utiliser un bloc comme à la ligne 8.

Ligne 2, les trois lettres "pas" sont considéré comme un ensemble.
Le remplacement ce fait seulement si les trois caractères sont réuni (le "a" de aime ou le "s" de les n'est pas affectés).
Ligne 3, les crochets désigne un caractère au choix.
Si j'ai utilisé les crochets alors qu'il n'y avait qu'un caractère, c'est parce que le symbole "/./" a une signification particulière.
On le voit clairement ligne 7, on aurait pu s'attendre à ce qu'il remplace tout les "." de la chaine.
En fait, ce symbole désigne chaque caractère de la chaine.
Ici, chaque caractère est remplacé par un tiret.
Ligne 10 et 11, le symbole "/[az]/" ne désigne pas l'ensemble "az" mais soit le caractère "a" soit le caractère "z" (comparez avec la ligne 2).
Voila ce qu'il est important de savoir sur la classe "String".

EXERCICE :

Il y a énormément de chose amusante à faire avec des String ...
Vous pouvez essayer de faire un programme de cryptage.
Pour cela, utilisez la méthode "gets" :



Code:
alpha = gets
puts alpha * 5
aa = gets

Cette méthode permet de récupérer une chaine entrée au clavier.
(Directement stocké dans la variable "alpha" dans l’exemple)
Le second "gets", c'est juste pour maintenir la fenêtre ouverte ...
(A noter : Si vous utilisez "gets", il faut tester depuis l'icone et non pas grâce à F5 !!)

Voila donc ce que vous pouvez faire :
Lui demander quelque type de cryptages est-ce qu'il veut.
Récupérer une chaine entrée par l'utilisateur.
Lui renvoyer son message mais crypté.

Pour la clé de cryptage, a vous de voir ...
(Remplacer une lettre par un chiffre, par une autre lettre, par une lettre grecque, par son équivalent en morse ou dans le tableau d'épellation (française, internationale ou radio), par un symbole ...)
Et pourquoi aussi prévoir la fonction "Décryptage" ...

La classe "Array" :

Les objets de la classe "Array" (ou plus simplement les tableaux) sont assimilables à des boites.
Des boites à la taille extensible à volonté et pouvant stocker toutes sortes d'objets.
(Des Integer, des String, d'autre Array ...)

Voici comment les créer :



Code:
tab = Array.new(2, "a")
puts tab
puts tab.to_s

tab = Array([1, "a", ["a", 2]])
puts tab
puts tab.to_s

tab = ["az", "er", "ty", 45, [1, 2, 3]]
puts tab
puts tab.to_s

tab = []

Ligne 1, on crée un tableau contenant deux fois la chaine "a".
"puts" peut soit afficher chaque entré d'un tableau, soit le tableau sous forme de String (grâce à la méthode "to_s").
Le tableau est un objet facilement identifiable, il est défini entre crochets.
Ligne 13, on voit un tableau vide.

Les tableaux sont mieux rangés qu'une simple boite.
Chaque entrée possède un index, qui est un peu comme une adresse.



Code:
tab = "azerty".split(//)
puts tab[0]
puts tab[1]
puts tab[2]
puts tab[3]
puts tab[4]
puts tab.at(5)

puts "_"

puts tab.index("z")
puts tab.index("y")

puts "_"

puts tab.first
puts tab.last

puts "_"

tab_bis = tab[2, 3]
puts tab[2..4].to_s
puts tab_bis.to_s

La méthode "split" sert à découper une String et à la renvoyer sous forme d’Array.
Le paramètre indique comment faire le découpage, ici c'est à chaque caractère.
(A ne pas confondre avec les symboles des "gsub" du chapitre précédent : le symbole "/./" aurait découpé la chaine à chaque "." rencontré)
"tab" est donc un tableau avec un caractère à chaque entré.
Ligne 2, "tab[0]" fait référence au premier élément du tableau.
Chaque élément à son index, en partant de "0".
Vous pouvez soit utiliser la méthode "at", soit utiliser des crochets.

La méthode "index" permet d'obtenir sous forme d'un Integer l'index de l'élément passé en paramètre.
La méthode "first" renvoi le premier élément du tableau.
La méthode "last" renvoi le dernier élément du tableau.

Les lignes 21 et 22 font référence à des choses que l'on a déjà vues avec les String.
Ces méthodes retournent un nouveau tableau basé sur le tableau d'origine.
(On peut utiliser un ensemble ou un intervalle)

Il existe d'autres méthodes ressemblant à celles déjà vu avec les String :



Code:
tab = ["A"] << "S" << "H" << "K" << ["A"]
puts tab.to_s

tab = [1, 2, 3, 4, 5, 6, 7, 8, 9] + [4, 5, 6]
puts tab.to_s

tab = [1, 2, 3, 4, 5, 6] | [4, 5, 6, 7, 8, 9]
puts tab.to_s

tab = [1,2,3,4,5,6,7,8,9] - [4, 5, 6]
puts tab.to_s

tab = [1, 2, 3, 4] & [1, 4, 7]
puts tab.to_s

tab = ["Yo !!"] * 5
puts tab.to_s

Ligne 1, on trouve une méthode qui permet d'ajouter de nouveau élément à un tableau.
(On peut également utiliser la méthode "concat»)



Code:
puts ["ASH"].concat(["KA"])

Ligne 4, la méthode "+" renvoi un nouveau tableau contenant tous les éléments des deux tableaux.
(On peut donc obtenir des éléments en "double»)
Ligne 7, la méthode "|" renvoi un nouveau tableau contenant des éléments des tableaux.
( Les éléments en "double" sont supprimés»)
Ligne 10, la méthode "-" renvoi un nouveau tableau contenant tous les éléments du premier tableau qui ne figure pas dans le deuxième.
Ligne 13, la méthode "&" renvoi un nouveau tableau contenant tous les éléments qui se trouvent dans les deux tableaux.
Ligne 16, la méthode "*" renvoi un nouveau tableau contenant plusieurs fois le tableau d'origine.



Code:
tab = "azerty".split(//)
puts tab.to_s

tab.push("u")
puts tab.to_s
puts tab.size

tab[2,3] = "ghj"
puts tab.to_s

tab[2] = "ert"
puts tab.to_s

tab[0..(tab.length - 1)] = "a"
puts tab.to_s

La méthode "push" sert à intégrer un nouvel élément dans le tableau.
(Il aura un index supérieur au précédent élément, les éléments déjà présents ne seront pas modifiés)

A l'instar de ce que l'on a vu pour les String, il est possible de modifier un tableau grâce au symbole d'affectation (= ).
On peut utiliser un ensemble ou un intervalle.

Remarquez aussi l'existence des méthodes "size" et "length".

Il existe des méthodes pour supprimer des éléments d'un tableau :



Code:
tab = [1,"a",2,"b",3,"c",4,"d","b"]
puts tab.to_s

tab.delete("b")
puts tab.to_s

tab.delete_at(tab.size - 1)
puts tab.to_s

tab.delete_if {|x| x.is_a?(Integer)}
puts tab.to_s

La méthode "delete" supprimera tous les éléments du tableau qui sont égaux au paramètre.
La méthode "delete_at" supprimera l'élément se trouvant à l'index passé en paramètre.
La méthode "delete_if" est associé à un bloc et supprimera tous les éléments vérifiant la condition du bloc.
(Le module "Comparable" est automatiquement inclut dans la classe "Array", vous pouvez donc utiliser les opérateurs de comparaisons <,>,<=,>=,==,!= )



Code:
tab = [["a", "b", "c"], [1, 2, 3], ["azertyuiop", "qsdfghjklm", "wxcvbn"], []]

puts tab.assoc(1).to_s
puts tab.rassoc("b").to_s
puts tab.size

tab.clear
puts tab.empty?

La méthode "assoc" est assez particulière.
Si un tableau contient d'autre tableau, cette méthode sert à rechercher le sous-tableau dont le premier élément est égal au paramètre.
Si elle trouve un tableau correspondant, elle le renvoi, sinon, elle renvoi "nil".
La méthode "rassoc" à le même effet, mais elle compare au deuxième élément des sous-tableaux.

On constate que la méthode "size" compte les éléments du tableau mais ne tient pas compte de la taille des éléments.
Ici, tous les tableaux sont un élément, le tableau vide n'est pas traité différemment des autres.
La méthode "clear" sert à supprimer tous les éléments d'un tableau.
La méthode "empty?" renvoi un booléen indiquant si le tableau est vide ou non.



Code:
tab = [ "a", "b", "c", "d" ]
puts tab.collect {|x| x + (x[0].to_i - 96).to_s }

tab = [ "a", "b", "c", "d" ]
tab.each {|x| puts x + (x[0].to_i - 96).to_s }

tab.each_index {|x|puts tab[x] + (x + 1).to_s }

tab = [1, nil, 2, nil, 3, nil]
puts tab
puts tab.compact

La méthode "collect" retourne un nouveau tableau modifié selon les commandes prévu dans le bloc passé en paramètre.
Il existe également une méthode "collect" qui renvoi le tableau d'origine modifié.

Les méthodes "each" et "each_index" exécute un bloc pour chaque élément passé en paramètre.
Avec "each", ces éléments sont directement les éléments du tableau.
Avec "each_index", les éléments sont les index des éléments du tableau.

La méthode "compact" renvoi un nouveau tableau âpres avoir supprimé tous les éléments égaux à "nil".
Il existe une méthode "compact!" qui renvoi le tableau d'origine modifié ou "nil" si aucune modification n'est faite.



Code:
tab = [[1, 2, 3], 4, 5, 6]

puts tab[0].to_s
tab.flatten!
puts tab[0].to_s
puts tab.flatten!

puts tab.include?("z")

puts tab.join
puts tab.join(" - ")

Lorsqu’un tableau contient d'autre tableau, la méthode "flatten!" modifie le tableau en supprimant les sous-tableaux et en intégrant leurs éléments respectifs au tableau d'origine.
(Comme son nom le suggère, elle renvoi "nil" s'il n'y a pas de sous-tableau - il existe aussi la méthode "flatten")

La méthode "include?" renvoi "true" si le paramètre est présent dans le tableau.

La méthode "join" fait la même chose que "to_s".
Elle retourne le tableau sous la forme d'une chaine.
Avec un paramètre, celui ci est ajouté après chaque élément du tableau.



Code:
tab = [1, 2, 3]

puts tab.unshift(0).to_s

puts tab.pop
puts tab.to_s

puts tab.shift
puts tab.to_s

Contrairement à "push" qui permet d'intégrer de nouveaux éléments "par l'arrière", "unshift" les intègrent par "l'avant".
Tous les éléments déjà présents sous donc décalé d'un cran.
"pop" renvoi le dernier élément du tableau tout en le supprimant.
(C’est très différent de "last" qui se contente juste de renvoyer le dernier élément sans modification)
"shift" renvoi le premier élément du tableau tout en le supprimant.
(C’est très différent de "first" qui se contente juste de renvoyer le premier élément sans modification)



Code:
tab = ["a","z","e","r","t","y"]
puts tab.reverse.join(".")

tab.reverse_each {|x| puts x + "-" + tab.index(x).to_s }

La méthode "reverse" renvoi un nouveau tableau en inversant l'ordre des éléments.
La méthode "reverse!" renvoi le tableau d'origine modifié ou "nil" si le tableau est inchangé (un seul élément par exemple).

La méthode "reverse_each" correspond à la méthode "each" mais elle part du dernier élément et fini par le premier.



Code:
tab = "azertyuiop".split(//)
puts tab.slice(0,6).join("-")
puts tab.slice(4...join

puts tab.sort.to_s

puts tab.sort {|a,b| a <=> b }.to_s
puts tab.sort {|a,b| b <=> a }.to_s

La méthode "slice" permet d'obtenir un nouveau tableau basé sur le tableau d'origine.
On peut utiliser un ensemble ou un intervalle.
La méthode "slice!" permet de directement modifier le tableau d'origine.

La méthode "sort" permet de récupérer un tableau trié.
On peut soit utiliser la méthode simple soit utiliser un bloc.
La ligne 7 permet d'obtenir un ordre croissant.
La ligne 8 permet d'obtenir un ordre décroissant.
(La méthode "sort!" modifie directement le tableau d’origine)

Voila qui conclu l'étude des méthodes de la classe "Array" !!

La classe "Hash" :

Un Hash ou table de hachage est assez ressemblant à un tableau.
Mais on n'utilise pas un index pour se retrouver.
On utilise plutôt une clé.
Cette clé peut être un Integer, une String, un Array ...

Voici comment en créer :



Code:
test = {1 => "a", "deux" => "2", [1, 2, 3] => "c"}
puts test[1]
puts test["deux"]
puts test[[1,2,3]]

puts test["azerty"]
test["azerty"] = "Yo !!"
puts test["azerty"]

puts test.to_s
puts test.clear
puts test.empty?

aa = Hash.new(0)
puts aa[159]
puts aa.default

aa.default = "azerty"
puts aa[159]

Le Hash est créé ligne 1.
Un hash est défini par des accolades.
Ici, on attribue une valeur à chaque clé selon le schéma : clé => valeur, clé => valeur ...
Ligne 2, on pourrait traduire par : " Afficher la valeur de la variable-hash "test" correspondant à la clé "1".
La chaine "deux" ou le tableau "[1,2,3]" sont également des clés.

Ligne 6, on voit qu'une clé qui n'est pas défini renvoi "nil".
On peut définir une clé soit lors de la création du Hash soit grâce au symbole d'affectation.

Les méthodes "to_s", "clear" et "empty?" n'ont déjà plus de secret pour nous ...

Ligne 14, on voit une autre façon de créer un Hash.
Le paramètre sert à définir une valeur par défaut.
Toutes les clés auront comme valeur ce paramètre tant qu'il ne leur en sera pas assigné une autre.
La méthode "default" permet renvoi cette valeur par défaut (soit "nil" s'il n'y en a pas de défini).
Ligne 18, on voit qu'il est possible d'assigner une valeur par défaut même après la création du Hash.

Nous avons déjà vu de nombreuses méthodes concernant les String ou les Array qui existent aussi pour les Hash ...



Code:
test = {1 => "a", 2 => "b", 3 => "c", 4 => "d", 5 => "e"}
puts test
puts test.delete("c")
puts test.delete(3)
puts test

puts test.delete_if {|key, valeur| key > 3 or valeur > "c"}

test = {1 => "a", 2 => "b", 3 => "c", 4 => "d", 5 => "e"}
test.each {|key, valeur| puts key.to_s + "-" + valeur }
test.each_key {|key| puts key.to_s if key >= 3}
test.each_value {|value|puts value if value <= "c"}

puts test.include?("b")
puts test.include?(2)
puts test.has_key?(5)
puts test.key?(2)
puts test.has_value?("b")
puts test.value?("a")

puts test[1]
puts test.index("b")

La méthode "delete" utilise une clé comme argument (ou paramètre).
Si on lui passe une valeur en paramètre, elle renvoi "nil".

La méthode "delete_if" est semblable à celle connu pour les tableaux, mais ici, on utilise la clé et la valeur comme paramètre dans le bloc.

Même chose pour la méthode "each", on utilise deux paramètres.
Il existe aussi une méthode spécifique pour les clés "each_key" et une spécifique pour les valeurs "each_value".

Comme la méthode "delete", la méthode "include?" utilise une clé comme argument, pas une valeur.

Les méthodes "has_key?" et "key?" sont équivalente et indique si le hash connais la clé passé en paramètre.
Les méthodes "has_value?" et "value?" sont équivalente et indique si le hash stocke la valeur passé en paramètre.

La méthode "index" sert à trouver la clé correspondant à une valeur.



Code:
test = {1 => "a", 2 => "b", 3 => "c", 4 => "d", 5 => "e"}
puts test.keys.to_s
puts test.keys.is_a?(Array)
puts test.values.to_s
puts test.values.is_a?(Array)

test = test.invert
puts test.keys.to_s
puts test.values.to_s

puts test.size
puts test.length

test = test.to_a
puts test.is_a?(Hash)
puts test.is_a?(Array)
puts test.to_s
test_bis = [["a",1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]
puts test == test_bis

La méthode "keys" renvoi sous forme d'Array toutes les clés définis.
La méthode "values" renvoi sous forme d'Array toutes les valeurs stockées dans le Hash.

La méthode "invert" sert à inverser les clés et les valeurs.
(La valeur devient clé, la clé devient valeur)

Pas de surprise concernant les méthodes "size" et "length" ...
La méthode "to_a" permet de créer un Array à partir d'un Hash.
La ligne 18 montre quelle forme prendra ce nouveau tableau.



Code:
test = {1 => "a", 2 => "b", 3 => "c"}
test.size.times do
puts test.shift.to_s + " <= shift"
puts test.to_s
end

test = {1 => "aze", 2 => "acs", 3 => "atg"}
puts test.to_s
puts test.sort.to_s
puts test.sort {|a, b|a[1] <=> b[1]}.to_s
puts test.sort {|a, b|b[1] <=> a[1]}.to_s

hash_un = {1 => "a", 2 => "b", 3 => "c"}
hash_deux = {3 => "cc", 4 => "dd", 5 => "ee"}
puts hash_un.to_s
puts hash_deux.to_s
puts hash_un.update(hash_deux).sort.to_s

La méthode "shift" renvoi sous forme d'Array la première clé et sa valeur tout en la supprimant du Hash.
Elle renvoi "nil" si le Hash est vide.

La méthode "sort" renvoi sous forme d'Array le Hash trié.
(Le tableau sera de la même forme que si on utilise la méthode "to_a")
On peut aussi utiliser un bloc.
(Ici, le 1 entre crochet fait référence à l'index du sous-tableau crée par le "sort".)

La méthode "update" permet de faire fusionner deux hash en renvoyant un nouveau hash.
Si deux clés identiques existent, le hash passé en paramètre prime).

C'est tout pour cette classe !!
Les Hash sont des outils très puissants, stockant un très grand nombre d'info et ce très simplement.

Nous en arrivons donc maintenant à la toute dernière partie de ce tutoriel.

Le module "Enumerable" :

Ce module est automatiquement inclut dans les classes String, Array et Hash.
Il fournit donc des méthodes pouvant (en théorie) être utilisés avec ces différents types d'objets.
En pratique les méthodes les plus utiles (celle ci dessous) sont surtout pour les Array :



Code:
test = ["a", "c", ["a", 1], 12]
puts test.find {|x| x.is_a?(Integer) }

puts test.find_all {|x| x.is_a?(String) }.to_s

test = [1, 58, 4, 78, 2, 54]
puts test.min.to_s
puts test.max.to_s

La méthode "find" est associé à un bloc.
Elle retourne le premier élément qui correspond à la recherche.
(Le premier élément vérifiant la condition se trouvant dans le bloc)

La méthode "find_all" retourne sous la forme d'un Array tout les éléments vérifiant la condition du bloc.

La méthode "min" retourne la plus petite valeur de l'ensemble.
La méthode "max" retourne la plus grande valeur de l'ensemble.

Voila, c'est la fin de ce tutoriel !!

Ouah, super même si je n'ai pas tout lu^^

C'est du copier-coller?
Parce que sinon je pense qu'il faut mettre la source^^

oui c'est du copier coller et la source je l'ai plus dsl

Tu connais le ruby?

oui je connais un peu