Discussion :

[puresprit]

Bonjour !

Mon source est un fichier codé en markdown, avec (potentiellement) des liens sur différentes URL. Typiquement :
$texte = "...blah... [libellé_1](http://www.site1.com) ...blah... [libellé_2](http://www.site2.com) ...blah..."

Je veux catcher ces Liens les uns après les autres, dans une boucle.
Donc au 1er passage, je cherche à matcher séparément le [libellé1] d'une part, le (lien site1) qui le suit d'autre part.

Pour ce faire, j'utilise 2 preg_match :
- pour le libellé : $int = preg_match ('/(\[.*\])/',$texte,$matches);
- & pour le lien : $int = preg_match ('/(\(.*\))/',$texte,$matches);

Sauf que chacune de ces expressions s'arrête sur la DERNIERE occurrence trouvée de "]" et de ")" et non sur la PREMIERE.
J'obtiens donc :
- pour le libellé : [libellé_1](http://www.site1.com) ...blah... [libellé_2]
- & pour le lien : (http://www.site1.com) ...blah... [libellé_2](http://www.site2.com)

...au lieu d'obtenir :
- pour le libellé : [libellé_1]
- & pour le lien : (http://www.site1.com)

Quelqu'un peut-il m'aider (....je suis NULL en expressions régulières... ) ?
Merci !

[mathieu]

essayer de mettre le mode "non glouton" en rajoutant un U comme cela : '/(\[.*\])/U'
regardez là pour plus d'informations sur les différents modes :
http://php.net/manual/fr/reference.p....modifiers.php


vous pouvez aussi tout récupérer en une seule fois comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

preg_match_all("/\[(.*)\]\((.*)\)/U", $texte, $matches, PREG_SET_ORDER);

[CosmoKnacki]

Déjà, si ton but est de transformer du texte, il s'agit d'un remplacement. Donc tu n'utilises pas la bonne méthode (preg_match se contente de trouver une occurrence et c'est tout). Tu devrais plutôt te tourner vers preg_replace ou preg_replace_callback suivant le type de remplacement que tu as à faire (erreur de débutant à éviter: rechercher avec preg_match puis remplacer avec preg_replace ou preg_replace_callback ou encore avec str_replace, ces fonctions trouvent et replacent à la fois). Qui plus est, ces fonctions remplacent toutes les occurences d'un texte et pas seulement la première, donc en utilisant l'une d'elles tu pourras te passer de boucle.

[EDIT] Oublie ce que j'ai écris au sujet du remplacement, j'avais lu "Je veux cacher ces Liens les uns après les autres..." au lieu de "Je veux catcher ces Liens les uns après les autres...".

Maintenant au sujet du problème d'arrêt: comme l'as dit mathieu, les quantificateurs sont gourmands (greedy) par défaut, et tu peux les rendre non gourmands en ajoutant un point d'interrogation après. * (gourmand) *?(non gourmand).

Ceci dit, un quantificateur non gourmand demande plus de travail au moteur de regex car à chaque caractère qu'il prend, il doit vérifier que le reste de l'expression régulière réussit, alors qu'un quantificateur gourmand prend tout ce qui est possible et se pose des questions après, quitte à devoir rendre des caractères pour que l'expression réussisse.

Comme tu peux le comprendre, aucun des deux comportements n'est meilleur que l'autre: l'un teste d'entré de jeu en avançant lentement, et l'autre avance vite mais teste après coup et éventuellement recule.

Une solution médiane consiste à profiter de la rapidité d'avancée du quantificateur gourmand tout en réduisant le nombre d'étapes de retour arrière et les tests qui en découlent. Pour ce faire la solution est très simple dans ton cas: il suffit d'interdire le caractère ] ou ) au lieu d'utiliser le point (qui représente n'importe quel caractère excepté \n). Pour ce faire, en lieu et place du point, il faut utiliser les classes de caractères en excluant le caractère voulu: [^]] ou [^)]. Ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

/\[[^]]*]/

et:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

/\([^)]*\)/

Pour faire des tests: regex101.com.
Pour comprendre le comportements des quantificateurs (entre autres): Mastering regular expressions _ J Friedl _ O'Reilly