PC SOFT

FORUMS PROFESSIONNELS
WINDEVWEBDEV et WINDEV Mobile

Accueil → WINDEV 2024 → Aide sur les expressions régulières
Aide sur les expressions régulières
Débuté par Johjo, 18 jan. 2018 13:56 - 7 réponses
Posté le 18 janvier 2018 - 13:56
Bonjour à tous,

je bloque sur un problème d'expression régulière et j'aimerai savoir s'il est possible de résoudre mon problème en passant par les expressions régulières (ou une autre fonction). Je n'ai pas envie de faire de boucle, ni de fonction récursive (si personne n'arrive à m'aider, alors, c'est ce que je ferai).

J'ai le code suivant :

url est une chaîne = "index/<param1>/<param2>"
t est un tableau de chaînes

VérifieExpressionRégulière(url, "([^<]*)<([^>]*)>([^<]*)<([^>]*)>(.*)", t)
Trace("---------" + RC + 1, RC + TableauVersChaîne(t))

VérifieExpressionRégulière(url, "(([^<]*)<([^>]*)>)*(.*)", t)
Trace("---------" +RC + 2, RC + TableauVersChaîne(t))


L'objectif est de récupérer toutes les chaines de caractères qui sont entre <> et ce quelque soit le nombre d'occurrence. Je peux en avoir 0, 1, 2, etc...

La première syntaxe fonctionne, mais elle ne permet d'avoir que deux éléments. Si j'en veux plus, il faut que je complète la chaîne.
La seconde syntaxe utilise les groupes multiples ( )*, j'aurai pensé que ça fonctionnerait, mais ce n'est pas le cas, et en plus, je ne comprend pas le résultat.

Si quelqu'un arrive à me trouver la solution, je pourrai vous soumettre une fonction qui permet de renvoyer un tableau associatif avec un équivalent de vérifieexpressionreguliere.

Je vous remercie !
Membre enregistré
265 messages
Popularité : +14 (16 votes)
Posté le 18 janvier 2018 - 14:50
Bonjour Johjo,

L'objectif est de récupérer toutes les chaines de caractères qui sont entre <> et ce quelque soit le nombre d'occurrence. Je peux en avoir 0, 1, 2, etc...


A ma connaissance ce n'est pas possible avec les expressions régulières.

Une boucle implique au moins de manipuler une variable.
Et il n'y a pas de notion de variables dans les RegExp.

Ma réf perso concernant les RegExp au passage :
https://qntm.org/files/re/re.html

Bon Dev !

--
René MALKA
Membre enregistré
309 messages
Popularité : +31 (37 votes)
Posté le 18 janvier 2018 - 15:29
Bonjour,
Essaie ceci :

url est une chaîne = "index/<param1>/<param2>"
t est un tableau de chaînes
t=ChaîneDécoupe(TableauVersChaîne(ChaîneDécoupe(TableauVersChaîne(ChaîneDécoupe(url,"/"),""),">"),""),"<")
Trace("---------" + RC + 1, RC + TableauVersChaîne(t))


Bon dev.
Posté le 18 janvier 2018 - 16:54
Merci à vous deux.
@René, les expressions régulières (mais pas celle de WinDev) permettent de récupérer des motifs qui se répètent. En gros, on peut récupérer un même motif 0,1 ou n fois. Avec WinDev, il n'y a que les caractères prix individuellement qui peuvent être récupéré 0, 1 ou n fois.

Par contre, je suis d'accord, à ma connaissance, il n'y pas de notion de variable dans les regexp, seulement des groupes nommés.

@Samir, t contient aussi index, ce qui me pose problème. J'ai essayé avec ChaineDécoupe, mais ça ne correspond pas à ce que je souhaitais.

Je me suis résolu à faire une boucle pour extraire mes paramètres et voici la fonction qui en découle :

Procedure vérifier_regexp_et_extraire_valeurs(chaine_testée est chaîne, expression_reguliere est une chaîne, tableau_de_valeurs est un tableau associatif de chaîne)
noms_des_parametres est un tableau de chaîne
valeurs_des_parametres est un tableau de chaîne
expression_reguliere_sans_nom est une chaîne

(noms_des_parametres, expression_reguliere_sans_nom) = extraire_noms_des_parametres(expression_reguliere)

SI vérifier_et_extraire_valeur_des_parametres(chaine_testée, expression_reguliere_sans_nom, valeurs_des_parametres) ALORS
// on remplit les valeurs de retours
POUR i = 1 _A_ Min(noms_des_parametres..Occurrence, valeurs_des_parametres..Occurrence)
tableau_de_valeurs[noms_des_parametres[i]] = valeurs_des_parametres[i]
FIN

RENVOYER Vrai
SINON
RENVOYER Faux
FIN

PROCEDURE INTERNE extraire_noms_des_parametres(_expression_reguliere est chaîne)
_nom_des_parametres est un tableau de chaîne
_elements est un tableau de chaînes = ["", "", _expression_reguliere]
_expression_reguliere_sans_nom est une chaîne

TANTQUE VérifieExpressionRégulière(_elements[3], "([^<]*)<([^>]+)>(.*)", _elements)
_expression_reguliere_sans_nom += _elements[1] + "(.+)"
Ajoute(_nom_des_parametres, _elements[2])
FIN

_expression_reguliere_sans_nom += _elements[3]

RENVOYER (_nom_des_parametres, _expression_reguliere_sans_nom)
FIN


PROCEDURE INTERNE vérifier_et_extraire_valeur_des_parametres(_chaine_testée est chaîne, _expression_reguliere_sans_nom est chaîne, _valeurs_des_parametres est tableau de chaîne)
SI VérifieExpressionRégulière(_chaine_testée, _expression_reguliere_sans_nom, _valeurs_des_parametres) ALORS
RENVOYER Vrai
SINON
RENVOYER Faux
FIN
FIN


et un exemple pour tester et comprendre :

t est un tableau associatif de chaîne
SI vérifier_regexp_et_extraire_valeurs("index/test1/test2", "index/<param1>/<param2>",t) ALORS
Trace(t["param1"], t["param2"])
FIN

SI vérifier_regexp_et_extraire_valeurs("index/test1@test2/test3", "index/<param1>@<param2>/<test3>",t) ALORS
Trace(t["param1"], t["param2"], t["test3"])
FIN


Merci beaucoup !
Membre enregistré
948 messages
Popularité : +30 (92 votes)
Posté le 18 janvier 2018 - 17:43
Coucou,

1) Tu ajoute l'assembly dotnet






2) Tu crée une collection de procédure avec le code suivant :

// https://forum.pcsoft.fr/fr-FR/pcsoft.fr.windev/95095-expressions-regulieres-regex-cherche-remplace/read.awp?lastview
// Assemblage : System
// Namespace : System.Text.RegularExpressions
// Greatz to @JurassicPork ;)
Procedure PUBLIC GLOBALE VérifieExpressionRégulière(_sValue est une chaîne, _sPatern est une chaîne, _arrSMatchs est un tableau de chaîne = Null): boolean
// Gestion des erreurs
ErreurChangeParamètre(epGotoCasErreur)
ExceptionChangeParamètre(epGotoCasException)
// Raz
TableauSupprimeTout(_arrSMatchs)
// Collection
_pclMatchCollection est un MatchCollection dynamique = Regex.Matches(_sValue,_sPatern)
POUR TOUT _Match de _pclMatchCollection
// Groups
POUR TOUT _Groups de _Match.groups
Ajoute(_arrSMatchs, _Groups.value)
FIN
FIN
// Summary
RENVOYER (_pclMatchCollection.Count > 0)
CAS ERREUR:
ErreurPropage()
RENVOYER Faux
CAS EXCEPTION:
ExceptionPropage()
RENVOYER Faux


// https://forum.pcsoft.fr/fr-FR/pcsoft.fr.windev/95095-expressions-regulieres-regex-cherche-remplace/read.awp?lastview
// Assemblage : System
// Namespace : System.Text.RegularExpressions
// Greatz to @JurassicPork ;)
Procedure PUBLIC GLOBALE VérifieExpressionRégulière(_sValue est une chaîne, _sPatern est une chaîne): boolean
// Gestion des erreurs
ErreurChangeParamètre(epGotoCasErreur)
ExceptionChangeParamètre(epGotoCasException)
// Collection
_pclMatchCollection est un MatchCollection dynamique = Regex.Matches(_sValue,_sPatern)
// Summary
RENVOYER (_pclMatchCollection.Count > 0)
CAS ERREUR:
ErreurPropage()
RENVOYER Faux
CAS EXCEPTION:
ExceptionPropage()
RENVOYER Faux


Example d'utilisation :
_arrSMatchs est un tableau de chaînes
_sValue est une chaîne = "index/<param1>/<param2><param3>/<param4>"
VérifieExpressionRégulière(_sValue, "\<(.*?)\>", _arrSMatchs)






--
In üs we trust - Autopsie Volume 1 disponible le 01-23 au dépôt de ton armurier.
Membre enregistré
309 messages
Popularité : +31 (37 votes)
Posté le 18 janvier 2018 - 17:56
@Charly : bonne idée de surcharger la fonction.

@JohJo : Utiliser une boucle, ok mais ta méthode me semble bien compliquée pour simplement extraire les chaines encadrées (à moins que quelques subtilités ne m'échappent) :

url est une chaîne="index/<param1>/<param2>"
t est un tableau de chaînes
POUR TOUTE chaîne unParam de url SEPAREE PAR ">"
TableauAjoute(t,ExtraitChaîne(unParam,2,"<"))
//tu peux ensuite affecter à ton tableau associatif
FIN
Trace("---------" + RC + 1, RC + TableauVersChaîne(t))


Bon dev.
Posté le 18 janvier 2018 - 22:45
@Charly :
effectivement, pour gérer les expressions régulières, .NET est nettement plus puissant que WinDev. Mais dans la mesure du possible, je souhaite que tous mes programmes soient sans dépendance avec un autre langage. Du coup, j'évite d'utiliser autre chose que du WinDev.
Mais l'idée est bonne. Dans le même ordre d'idée, pour gérer les expressions régulières, on peut aussi utiliser le vbscript.

@Samir:
Il y a deux subtilités :
- La première, c'est que je suis pleinement rodé à utiliser ma méthode pour extraire des zones. J'avoue qu'elle n'est pas facile à lire, à comprendre, et qu'elle n'est pas optimisée. Mais lorsqu'il s'agit d'extraire des données avec des séparateurs qui font plus d'un caractère, elle est très pratique.
- La seconde, c'est que je suis sûr que ce que j'extrais se situe bien entre < et >. Dans ton cas, s'il manque un < ou s'il y en a deux qui se suivent, l'extraction peut être incohérente. Mais en te répondant, je me rend compte que mon code n'est pas tout à fait juste, je vais le corriger de ce pas.

Merci pour vos retours.

Bonne journée à vous deux !
Membre enregistré
948 messages
Popularité : +30 (92 votes)
Posté le 23 janvier 2018 - 21:31
Up !

--
In üs we trust.
Autopsie Volume 1 disponible au dépot de ton armurier: http://www.sitealademande.com/sitealamande/anywhere/depot