[Résolu] Aide pour comprendre Ruby

Bonjour tous le monde,

J'aimerais un éclairage sur comment Ruby comprend la formule suivante:

Code:

/<(?:DEX|dex)[ ]*([\+\-]\d+)>/i

Le tout doit former une chaine de caractère (vu que le code que je regarde compare ensuite cette formule à une chaine). Je crois comprendre que (?:DEX|dex) donne le choix que l'expression dex soit écris en minuscule ou majuscule
Ensuite je ne comprends pas ce que signifie la suite caractères --'.

J'ai beau chercher sur le Web, je trouve pas de site qui explique comment décortiquer une telle formule.

PS :Qu'est ce que vous conseillerez comme livre pour quelqu'un qui cherche à approfondir un peu le Ruby. (pour par exemple, comprendre et savoir écrire comme la formule qu'on voit au dessus)

Merci d'avance

Ha ! Ca m'amuse beaucoup de répondre à ce type de question.
Déjà c'est une expression régulière. (on la détermine par l'encadrement /expr/)
Tu as du mérite. Je ne connais pas ton niveau en programmation, mais se pencher sur les regexp est très courageux !

On va procéder par étapes: *** représente ce que l'on a pas encore étudié:
1) /***/i
le i signifie que l'expression régulière ne prend pas en compte la casse des caractères.

2) /<***>/i
l'expression cherche à récupérer la valeur d'une balise de type html: <balise>

3) /<(***)***(***)>/i
tu as en tout trois blocs d'expressions. Donc ta chaine doit avoir une forme: <x y z >

4) /<(?:DEX|dex)***(***)>/i
?: effectue un groupement d'expression régulière sans répétition. DEX|dex, tu l'as compris est une condition "ou". Mais elle n'est pas du tout utile dans cette expression régulière car elle ne prend pas en compte la casse ("/i" à la fin)
Donc la chaine a cette forme: <dex y z> ou <DEX y z>

5) /<(?:DEX|dex)[ ]*(***)>/i
[]* sert à indiquer la présence ou non d'un ou plusieurs expaces. La chaine peut prendre la forme: <dex y z> ou <dexy z>

6) /<(?:DEX|dex)[ ]*([\+\-]\d+)>/i
[\+\-] sert à indiquer la présence ou non d'un signe + ou - au choix. Ces signes sont inclus dans la chaine et ne sont pas ici considéré comme des symboles d'expression régulière (contrairement à ? ou : du début). Il faut les échapper, c'est pourquoi, on met un \ devant
\d+ indique qu'il faut remplacer un ou plusieurs (car il y a un +) chiffre (d comme digit en anglais).

Donc ta chaine doit avoir la forme:
<DEX-123>
<DEX+123>
<DEX -123>
<DEX +123>
<dex-123>
<dex+123>
<dex -123>
<dex +123>

et cela renvoie: 123

Perso, je l'aurais fait comme ceci:

Code:

/<(?:dex)[ ]*([\+\-]\d+)>/i

Pour ce qui est de l'apprentissage ruby... laisse dans un premier temps tomber ce type de commande. C'est super prise de tete et il y a beaucoup plus intéressant.

(Tant mieux si tu as adoré répondre, moi j'ai adoré lire ^^)

Ok, c'est déjà un peu plus clair. (En programmation, ben.. j'ai 2 années d'expérience mais dans d'autre langages. Mes cours étaient surtout accès sur OCaml et C++)

Quand tu dis cela te renvoie 123, tu veux dire que l'expression marche comme une méthode ?
Si j'écris

Code:

 <dex +123>./<(?:dex)[ ]*([\+\-]\d+)>/i

je vais obtenir 123 ?


PS: Pour ce que je script d'autre en Ruby, je tente de faire un menu pour permettre à mes héros de manger entre les repas combats. Tout marche à peu près pour le moment (j'ai reussi à faire une liste de plus de 16 recettes en faisant défiler la fenêtre de commande quand on descend trop bas), sauf qu'il ya une erreur que je suis pas capable de comprendre.

tu dois faire:

Code:

/<(?:dex)[ ]*([\+\-]\d+)>/i.match("<dex +123>")

Le résultat de l'expression est assigné à la variable systeme: $1

donc:

Code:

/<(?:dex)[ ]*([\+\-]\d+)>/i.match("<dex +123>")
puts $1
=> "+123"


Merci beaucoup des réponses Berka.

Deux question pour finir avec ce type de filtre: si l'envi me prend de filtrer différent nombre en même temps :

Code:

/<(?:dex)[ ]*([\+\-]\d+[)[ ]*(\d\d\d[\%])>/i.match("<dex +123 120%>")

Est ce que le résultat filtré la deuxième fois sera contenu dans $2?

Ensuite, quelle valeur prend $1 si la chaine filtrée ne correspond pas du tout à ce qui est attendu :

Code:

/<(?:aux)[ ]*([\-]\d+[)[ ]*(\d\d\d[\%])>/i.match("<dex -123>")

Et enfin une dernière question, (pas trouvé de réponse encore sur le Web à ce jour) est qu'il ya un moyen pour ouvrir une fenetre "Invite de commande" quand le jeu se lance (histoire de pouvoir faire des tests sur ce qui se passe vraiment dans le programme quand le jeu tourne)?

Déjà, tu dois faire cela:

Code:

/<(?:dex)[ ]*([\+\-]\d+)[ ]*(\d+[ ]*\%)>/i.match("<dex +123 120%>")

\d+ répete le masque jusqu'à la rencontre de la prochaine expression.
Tu t'es embrouillé dans les [ et ]
Ici:
$1 = "+123"
$2 = "120%"

Si dans ton second cas, la seconde expression à "filtrer" (ce qui devrait etre $2) est mauvaise ou n'existe pas, l'ensemble de l'expression régulière renvoie nil.

Pour ton invite de commande, tu voudrais un truc pour coder en live en ruby ?
J'ai fait ça il y a longtemps: invite ruby
Malheureusement les créateurs du programme n'ont pas prévu de log d'exécution du jeu. Tu ne peux pas savoir ce qui s'exécute en tant réel en cours de jeu.

Ok.
(je voulais effectivement voir ce qui s'exécute en temps réel dans le jeu. Je vais essayer autrement)

Merci pour tout!

Hop, c'est résolu, je locke ;D