Expréssion réguliaire

[sospel]

Bonjour !

Compte tenu des inestimables contributions de dayvid à la programmation en général et à PUREBASIC en particulier, ne serait-il pas possible aux administrateurs du Forum de créer un sous-forum qui lui serait réservé, et que l'on pourrait nommer (en anglais, pour que le monde anglo-saxon puisse aussi en profiter) : "SHADOCK PROGRAMMING FORUM" ?

On pourrait y apprendre comment "faire simple quand on peut faire compliqué", comment s'exprimer en "charabia", comment empiler 2 fautes de grammaire tous les 3 mots ... et, cerise sur le gâteau, apprendre les mille et une façons de chialer en rendant "les autres" responsables de ses propres âneries ! Comme l'a dit fort justement DOBRO : "il veut des mouchoirs ? ".

Quand ce zombie de la programmation aura étudié par lui-même les multiples exemples de DOBRO, de COMTOIS et de quelques autres, il pourra poser des questions pertinentes qui serviront à la communauté des utilisateurs de ce puissant langage qu'est PUREBASIC. Alors que jusqu'à présent, il applique plutôt l'une des profondes réflexions shadokiennes : "En essayant continuellement, on finit par réussir. Donc, plus ça rate, plus on a de chance que ça marche"...

Je doute également que lui faire ses devoirs contribue à le faire progresser. J'ai admiré la patience de SPH et de quelques autres , mais n'est-elle pas contre-productive ? Quand on a affaire à un simulateur psychopathe, il me semble vain de s'apitoyer sur son sort ...

En plus, depuis quelques jours, il devient vite grossier et vulgaire : il est dommage à ce sujet que les administrateurs aient récemment retiré d'un de ses posts certaines de ses réactions qui suintaient plus la haine des autres que des remerciements pour tous les conseils qui lui sont prodigués ... Les nouveaux venus sur ce Forum auraient pu juger sur pièce !

Enfin, last but not least, je crains que ce genre de post ne soit pas la meilleure publicité pour un forum PUREBASIC.

Que doivent penser en effet les lecteurs occasionnels qui "tombent" sur ces listings sans fin ? Ils peuvent sans doute à juste titre se demander, au vu des N répétitions d'instructions identiques dont sont truffées les élucubrations dayvidiennes, si ce langage connaît les notions de "boucle", de "Select Case" ou de "Structure" . Il serait dommage de perdre ainsi de potentiels acheteurs du langage de FRED !

Bon, ceci dit, ce "SHADOCK PROGRAMMING FORUM" aurait quand même un avantage : celui du divertissement. De temps en temps, entre deux cogitations pour peaufiner quelques instructions passées au crible du rasoir d'Ockham, on pourrait y jeter un coup d'oeil pour rigoler un peu, de la même façon que l'on va au cirque pour voir le numéro des clowns et amuser les enfants. En principe ... parce qu'il y a aussi des clowns piteux et grotesques ...

Sospel

[Parole De JOJO]

J'ai trouve des excellents tutoriels pour apprendre les regex, en voici les liens.
c'est en language php, mais la base est la meme.
bonne chance

et vous les autres, pas la peine d'etre comme ca..

http://www.siteduzero.com/tutoriel-3-14 ... e-1-2.html
http://g-rossolini.developpez.com/tutoriels/php/regex/

[dayvid]

@sospel Je te connais même pas toi mais c pas grabve car je t'aime pas déjà
@Parole De JOJO >> merci a toi

[dayvid]

; Nous allons rajouté un signe astérisque (*) après notre t de chat.
; Cela signifie que notre lettre t pourra se retrouver 0, 1, 2, ... fois dans notre chaîne.
; Autrement dit, notre expression chat* sera trouvée dans
; les chaînes suivantes: 'chat', 'chaton', 'chateau', 'herbe à chat', 'chapeau', 'chatterton', 'chattttttttt'...

If CreateRegularExpression(0, "chat*", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "chat") ; 1
Debug MatchRegularExpression(0, "chaton") ; 1
Debug MatchRegularExpression(0, "chateau") ; 1
Debug MatchRegularExpression(0, "un chateau d'eau") ; 1
Debug MatchRegularExpression(0, "chapeau") ; 1
Debug MatchRegularExpression(0, "chatterton") ; 1
Debug MatchRegularExpression(0, "chattttttttt") ; 1

; Ici, notre expression chat* ne sera pas trouvée
; Tous simplement parceque toutes les lèttres doivent être en minuscule !:

Debug MatchRegularExpression(0, "Cha") ; 0
Debug MatchRegularExpression(0, "ChAt") ; 0
Debug MatchRegularExpression(0, "CHAT") ; 0
Debug MatchRegularExpression(0, "Chattt") ; 0

Else
Debug RegularExpressionError()
EndIf


; Dans nos exemples ci dessous, le signe * n'agit que sur la lettre qui le précède, pas sur les autres avant ni sur celles après.
; Cette expression est trouvée dans les chaînes suivantes:

If CreateRegularExpression(0, "bat*e", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "bateau") ; 1
Debug MatchRegularExpression(0, "batteur") ; 1
Debug MatchRegularExpression(0, "joan baez") ; 1
Debug MatchRegularExpression(0, "batttteur") ; 1

Else
Debug RegularExpressionError()
EndIf

; Il existe d'autres signes permettant de contrôler l'occurence:

; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; | Signe Explication Exemple d'expression Exemples de chaînes contenant l'expression
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; | * signifie 0, 1 ou plus abc* 'ab', 'abc', 'abcc', 'abcccccc'
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; | + signifie 1 ou plus abc+ 'abc', 'abcc', 'abccc'
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; | ? signifie 0 ou 1 abc? 'ab', 'abc'
; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------

; Vous pouvez également contrôler précisément le nombre d'occurences grâce aux accolades:

; E{4}: signifie 4 fois la lettre E majuscule
; E{2,4}: signifie de 2 à 4 fois la lettre E majuscule
; E{,5}: signifie de 0 à 5 fois la lettre E majuscule
; E{8,}: signifie 8 fois minimum la lettre E majuscule.

; abc{2}: chaine qui contient "ab" suivie de deux "c"
; abc{2,}: chaine qui contient "ab" suivie de deux "c" ou plus
; abc{2,4}: chaine qui contient "ab" suivie 2, 3 ou 4 "c"

; Note: le premier nombre de la limite est "{0,2}", et non pas "{,2}"
; Les symboles vus précédemment ("*", "+", et "?") sont équivalents à "{0,}", "{1,}", et "{0,1}".

If CreateRegularExpression(0, "abc{2}", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "abcd") ; 0
Debug MatchRegularExpression(0, "abdcc") ; 0
Debug MatchRegularExpression(0, "abcc") ; 1
Debug MatchRegularExpression(0, "asdefabc") ; 0
Debug MatchRegularExpression(0, "abdabeabcabfabccabh") ; 1
Debug MatchRegularExpression(0, "abccccc") ; 1, saut que ici il y as 5 "c" et qu'il étais dit: chaine qui contient "ab" suivie de deux "c"

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "abc{2,}", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "abcd") ; 0
Debug MatchRegularExpression(0, "abdcc") ; 0
Debug MatchRegularExpression(0, "abcc") ; 1
Debug MatchRegularExpression(0, "asdefabc") ; 0
Debug MatchRegularExpression(0, "abdabeabcabfabccabh") ; 1
Debug MatchRegularExpression(0, "abccccc") ; 1, la ok

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "abc{2,4}", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "abcd") ; 0
Debug MatchRegularExpression(0, "abdcc") ; 0
Debug MatchRegularExpression(0, "abcc") ; 1
Debug MatchRegularExpression(0, "asdefabc") ; 0
Debug MatchRegularExpression(0, "abdabeabcabfabccabh") ; 1
Debug MatchRegularExpression(0, "abcccccc") ; 1, saut que ici il y as 6 "c" et qu'il étais dit: chaine qui contient "ab" suivie 2, 3 ou 4 "c"

Else
Debug RegularExpressionError()
EndIf


; Vous pouvez préciser entre crochets plusieurs caractères ou classes de caractères.
; Par exemple, si vous entrez [abcd] cela signifie : soit la lettre a, b, c ou d.
; Pour exprimer des classes, vous pouvez utiliser le tiret - entre deux lettres.
; Par exemple, l'expression [A-Z] signifie "une lettre majuscule".
; Vous pouvez préciser plusieurs classes ou possibilités dans votre expression.
; Par exemple l'expression [A-Za-z0-9] signifie "une lettre, majuscule ou minuscule, ou un chiffre".
; Vous pouvez aussi contrôler l'occurence des classes comme nous l'avons vu juste au-dessus.
; Si vous voulez par exemple rechercher 5 lettres majuscules se suivant dans une chaîne, votre expression sera [A-Z]{5}.

; Si vous voulez appliquer ce contrôle d'occurence sur plusieurs caractères, vous allez mettre ces caractères entre parenthèses.
; Exemple: (cha){2,5}

; Cette expression sera vraie pour les chaînes contenant 'cha' répétée entre deux et cinq fois. Les 'cha' doivent se suivre naturellement

If CreateRegularExpression(0, "(cha){2,5}", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "un chateau") ; 0
Debug MatchRegularExpression(0, "un cha") ; 0
Debug MatchRegularExpression(0, "un chacha") ; 1
Debug MatchRegularExpression(0, "le chachacha est gris") ; 1
Debug MatchRegularExpression(0, "le chachachachachachacha") ; 1, saut que ici il y as 7 cha et qu'i étais dit: "répétée entre deux et cinq fois. Les 'cha' doivent se suivre naturellement", devrait donc être faux !
Debug MatchRegularExpression(0, "le cha à cha du cha est cha") ; 0

Else
Debug RegularExpressionError()
EndIf


; Les symboles ^ et $ indiquent le début ou la fin d'une chaîne, afin de la délimiter.

; ^debut: chaine qui commence par "debut"
; fin$: chaine qui se termine par "fin"
; ^chaine$: chaine qui commence et se termine par "chaine"
; abc: chaine contenant la chaine "abc"
;

If CreateRegularExpression(0, "^debut", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "le debut de la fin") ; 0
Debug MatchRegularExpression(0, "la fin du debut") ; 0
Debug MatchRegularExpression(0, "debut d'une histoire") ; 1
Debug MatchRegularExpression(0, "debut du debut de la fin") ; 1
Debug MatchRegularExpression(0, "debuter par rien") ; 1
Debug MatchRegularExpression(0, "debutera par une lèttre") ; 1
Debug MatchRegularExpression(0, "debutdebutdebut") ; 1

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "fin$", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "le debut de la fin") ; 1
Debug MatchRegularExpression(0, "la fin du debut") ; 0
Debug MatchRegularExpression(0, "fin d'une histoire") ; 0
Debug MatchRegularExpression(0, "fin du debut de la fin") ; 1
Debug MatchRegularExpression(0, "debuter par finter") ; 0
Debug MatchRegularExpression(0, "fin par une lèttre") ; 0
Debug MatchRegularExpression(0, "finfinfin") ; 1

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "^chaine$", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "chainer de la chaine de la fin") ; 0
Debug MatchRegularExpression(0, "la chaine du debut") ; 0
Debug MatchRegularExpression(0, "chaine d'une histoire") ; 0
Debug MatchRegularExpression(0, "chaine de debut du chaine de la chaine") ; 0
Debug MatchRegularExpression(0, "debuter par une chaine de rien") ; 0
Debug MatchRegularExpression(0, "chainerra par un debut de lèttre de chaine") ; 0
Debug MatchRegularExpression(0, "chaine") ; 1

Else
Debug RegularExpressionError()
EndIf


; abc+: chaine qui contient "ab" suivie de un ou plusieurs "c"
; ^abc+: chaine qui commence par "ab" suivie de un ou plusieurs "c"

If CreateRegularExpression(0, "abc+", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "abc") ; 1
Debug MatchRegularExpression(0, "abccc") ; 1
Debug MatchRegularExpression(0, "abde") ; 0
Debug MatchRegularExpression(0, "l'abc") ; 1
Debug MatchRegularExpression(0, "bcdcc") ; 0
Debug MatchRegularExpression(0, "labcabc") ; 1
Debug MatchRegularExpression(0, "adefabdcc") ; 0
Debug MatchRegularExpression(0, "abcabcabcabc") ; 1
Debug MatchRegularExpression(0, "abcdefababcda") ; 1

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "^abc+", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "abc") ; 1
Debug MatchRegularExpression(0, "abccc") ; 1
Debug MatchRegularExpression(0, "abde") ; 0
Debug MatchRegularExpression(0, "l'abc") ; 0
Debug MatchRegularExpression(0, "bcdcc") ; 0
Debug MatchRegularExpression(0, "labcabc") ; 0
Debug MatchRegularExpression(0, "adefabdcc") ; 0
Debug MatchRegularExpression(0, "abcabcabcabc") ; 1
Debug MatchRegularExpression(0, "abcdefababcda") ; 1

Else
Debug RegularExpressionError()
EndIf


; Les parenthèses ( ) permettent de représenter une séquence de caractères.

; "a(bc)*": chaîne qui contient "a" suivie de zero "bc" ou plus

If CreateRegularExpression(0, "a(bc)*", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "ab") ; 1
Debug MatchRegularExpression(0, "abccc") ; 1
Debug MatchRegularExpression(0, "abde") ; 1
Debug MatchRegularExpression(0, "l'abc") ; 1
Debug MatchRegularExpression(0, "bcdcc") ; 0
Debug MatchRegularExpression(0, "labcabc") ; 1
Debug MatchRegularExpression(0, "adefabdcc") ; 1
Debug MatchRegularExpression(0, "abcabcabcabc") ; 1
Debug MatchRegularExpression(0, "abcdefababcda") ; 1

Else
Debug RegularExpressionError()
EndIf


; La barre verticale | se comporte en tant qu'opérateur OU.
;
; un|le: chaîne qui contient "un" ou "le"
; (un|le) chien: chaîne qui contient "un chien" ou "le chien"
; (a|b)*: chaîne qui contient une suite de "a" ou de "b"

If CreateRegularExpression(0, "un|le", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "le chien du maitre") ; 1
Debug MatchRegularExpression(0, "un chien qui a sauver son maitre") ; 1
Debug MatchRegularExpression(0, "le chien du berger a un petit chien") ; 1
Debug MatchRegularExpression(0, "l'chien") ; 0
Debug MatchRegularExpression(0, "lechien") ; 1
Debug MatchRegularExpression(0, "chienle") ; 1

Else
Debug RegularExpressionError()
EndIf

If CreateRegularExpression(0, "(un|le) chien", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "le chien du maitre") ; 1
Debug MatchRegularExpression(0, "un chien qui a sauver son maitre") ; 1
Debug MatchRegularExpression(0, "le chien du berger a un petit chien") ; 1
Debug MatchRegularExpression(0, "l'chien") ; 0
Debug MatchRegularExpression(0, "lechien") ; 0
Debug MatchRegularExpression(0, "chienle") ; 0

Else
Debug RegularExpressionError()
EndIf

; Ici rien ne fonctionne comme prévus

If CreateRegularExpression(0, "(a|b)*", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "adfb") ; 1
Debug MatchRegularExpression(0, "adafagahaj") ; 1
Debug MatchRegularExpression(0, "agabavabafabahab") ; 1
Debug MatchRegularExpression(0, "l'edf") ; 1
Debug MatchRegularExpression(0, "ab") ; 1
Debug MatchRegularExpression(0, "aaabbb") ; 1

Else
Debug RegularExpressionError()
EndIf

; Le point . indique n'importe quel caractère (une fois).

; ^.{3}$: chaîne qui contient 3 caractères

If CreateRegularExpression(0, "^.{3}$", #PB_RegularExpression_DotAll)

Debug MatchRegularExpression(0, "adfb") ; 0
Debug MatchRegularExpression(0, "4d+") ; 1
Debug MatchRegularExpression(0, "agabavabafabahab") ; 0
Debug MatchRegularExpression(0, "l'e") ; 1
Debug MatchRegularExpression(0, "ab") ; 0
Debug MatchRegularExpression(0, "aaabbb") ; 0

Else
Debug RegularExpressionError()
EndIf

; Les crochets [ ] définissent une liste de caractères autorisés (ou interdits).
; Le signe - permet, quant à lui, de définir un intervalle. Le caractère ^ après le premier crochet indique une interdiction.

; [abc]: chaîne qui contient un "a", un "b", ou un "c"
; [a-z]: chaîne qui contient un caractère compris entre "a" et "z"
; [^a-zA-Z]: chaîne qui ne commence pas par une lettre

; Pour rechercher un caractère faisant partie des caractères spéciaux, il suffit de le faire précéder d'un antislash (un antislash doit donc être doublé)
; SAUF entre crochets. En effet, dans les crochets, chaque caractère représente ce qu'il est.
; Pour représenter un ] il faut le mettre en premier (ou après un ^ si c'est une interdiction), un - se met en premier ou en dernier.

; [\+?{}.]: chaîne qui contient un de ces six caractères
; []-]: chaîne qui contient le caractère "]" ou le carcatère "-"

; Il peut également être utile de vérifier si une chaîne contient des caractères d'un certain type (numérique, alphanumérique, ...) sans avoir à les énumérer. Pour cela, les expressions régulières définissent des classes de caractères, dont la syntaxe est : [:classe:]
; Les classes de caractères sont celles définies par UNIX.

; En voici quelques-unes :

; Classes de caractères
; [:alnum:] caractère alphanumérique (équivalent à [A-Za-z0-9])
; [:alpha:] caractère alphabétique ([A-Za-z])
; [:blank:] caractère blanc (espace, tabulation)
; [:ctrl:] caractère de contrôle (les premiers du code ASCII)
; [:digit:] chiffre ([0-9])
; [:graph:] caractère d'imprimerie
; [:print:] caractère imprimable (tout sauf les caractères de contrôle)
; [:punct:] caractère de ponctuation
; [:space:] caractère d'espacement
; [:upper:] caractère majuscule
; [:xdigit:] caractère hexadécimal

; Exemples :

; ^[:alnum:]+$: chaîne composée d'un (ou plusieurs) caractère(s) alphanumérique(s)
; [:punct:]|[:space:]: chaîne contenant un caractère de ponctuation ou un caractère d'espacement
; ^[:digit:]+$: nombre