soucis expression reguliere

[de_prog]

Bonjour,

j'utilise un expression reguliere simple pour délimiter ce qui se trouve à l'intérieur d'une div :

 $test = eregi('<div class="content">(.*)</div>',$valeur,$texte);

$valeur = $texte[0];

le problème est que cette expression me prend tout ce qui commence par <div class="content"> et se termine au dernier </div> qu'elle trouve dans le texte (donc prend d'autre contenu de div non désiré).

comment lui dire arrete toi au premier </div> que tu trouveras... ?

merci pour votre aide.

 

[Serious]

preg_replace avec PCRE_UNGREEDY
http://fr2.php.net/manual/fr/reference. ... ifiers.php
http://fr2.php.net/manual/fr/function.preg-replace.php

 

[de_prog]

Merci pour ta réponse

effectivement, c'est quelquechose comme ça qu'il me faut .
j'y arrive pas encore, j'ai fait quelquechose comme ça :

//$test = preg_replace("/<div class=\"texte\">(.*?)<\/div>$/U", "\\1\\2\\3",$valeur) ;

ça à pas l'air d'être ça encore... mais j'y travaille

 

[medium69]

Cela ça devrait être bon

preg_match('#<div class="content">(.*)</div>#'Us, $texte, $matches); // le paramètre « s » est nécessaire uniquement si il y a des retours à la ligne

echo $matches[0];

Je vois que tu te sert de « / » comme délimiteur. C'est peut-être à cause de moi, car j'ai dû te donner une regex avec ce dernier.
Comme le délimiteur peut être n'importe quel caractère, je l'ai remplacé par « # » ; ainsi tu n'a plus à échappé les « / ».

Dans le code que je te donne il te trouve uniquement ce qui correspond au masque. Si tu veux traiter cette partie, il y à d'autre fonctions :

preg_replace ou preg_replace_callback pour des traitements hards

 

[de_prog]

effectivement ça fonctionne nikel !!!

en fait, je pensais qu'il suffisait de placer le $ à la fin et le U pour qu'il comprenne de s'arrêter dès le premier </div> mais non...

merci 100000 fois pour tes aides en expression régulière...

 

[medium69]

effectivement ça fonctionne nikel !!!

en fait, je pensais qu'il suffisait de placer le $ à la fin et le U pour qu'il comprenne de s'arrêter dès le premier </div> mais non...

merci 100000 fois pour tes aides en expression régulière...

le $ sert à indiquer la fin de la chaine. ^ pour le début.

Le U permet de rendre la regex moins gourmande ; il n'est pas forcément nécessaire sur toutes les regex, mais il ne mange pas de pain... autant le laisser donc.

Un site parmi tant d'autre sur les regex : http://www.expreg.com/index.php

Tu verras... le jour où tu comptrendra toutes les astuces des regex, tu trouvera que le chinois est un jeu d'enfant :wink:

 

[medium69]

Pour info...

$matches[0] récupère l'ensemble de la chaine répondant au masque.

$matches[1] fonctionnerait dans ce cas, car il récupère le contenu de la première parenthèse ; $matches[2] pour la seconde, etc.

Si tu n'a pas besoin de garder le contenu d'une parenthèse, tu peux la mettre ainsi : (?:tonMasque) le « ?: » permet de ne pas mettre en variable le contenu.

Pour mémoire, les preg sont toujours plus rapide que les ereg.

 

[Serious]

Pour mémoire, les preg sont toujours plus rapide que les ereg.

Meme
Ce n'est pas vrai, ereg() est dans bien des cas plus rapide (jusqu'a 30% plus rapide avec PHP5). Il suffit de faire les tests car ca depend de l'expr rationnelle. Et pour les chaines constantes, strpos() est deux fois plus rapide.
Ces chiffres sont pour un PHP sans accelerateur et peuvent etre completement differents si on en utilise un.

 

[medium69]

Pour mémoire, les preg sont toujours plus rapide que les ereg.

Meme
Ce n'est pas vrai, ereg() est dans bien des cas plus rapide (jusqu'a 30% plus rapide avec PHP5). Il suffit de faire les tests car ca depend de l'expr rationnelle. Et pour les chaines constantes, strpos() est deux fois plus rapide.
Ces chiffres sont pour un PHP sans accelerateur et peuvent etre completement differents si on en utilise un.

Merci de m'avoir repris sur ce point, car je croyais que c'était toujours d'actualité.

Cela dit, ereg() ne permet pas de recherches complexes.

 

[medium69]

Pour mémoire, les preg sont toujours plus rapide que les ereg.

Meme
Ce n'est pas vrai, ereg() est dans bien des cas plus rapide (jusqu'a 30% plus rapide avec PHP5). Il suffit de faire les tests car ca depend de l'expr rationnelle. Et pour les chaines constantes, strpos() est deux fois plus rapide.
Ces chiffres sont pour un PHP sans accelerateur et peuvent etre completement differents si on en utilise un.

Je viens de faire un test ; c'est surprenant... je ne pensais pas que c'était aussi vrai.

Test effectué avec PHP5 sans accélérateur

// Contrôle du temps d'exécution d'un script
$time_start = microtime(true);

for($nb=0; $nb<1000000; $nb++) {
	$value = 'test de texte - cool - ';
	$test = preg_match('# - $#U', $value);
}

$time_end = microtime(true);
$time = $time_end - $time_start;

echo '<p>le script N°1 a duré '.number_format($time, 3, ',', ' ').' secondes</p>';

$time_start = microtime(true);

for($nb=0; $nb<1000000; $nb++) {
	$value = 'test de texte - cool - ';
	$test = ereg(' - ', $value);
}
$time_end = microtime(true);
$time = $time_end - $time_start;

echo '<p>le script N°2 a duré '.number_format($time, 3, ',', ' ').' secondes</p>';

 

[Serious]

J'ai legerement modifie ton script pour tester plusieurs motifs et la conclusion s'impose: ca depend de la regexp.

pattern:' - '       preg:2,167s  ereg:3,155s  PREG
pattern:' - $'      preg:2,471s  ereg:4,002s  PREG
pattern:'. - '      preg:3,783s  ereg:3,454s  EREG
pattern:'. - $'     preg:4,602s  ereg:4,307s  EREG
pattern:'(.) - '    preg:5,132s  ereg:3,824s  EREG
pattern:'(.) - $'   preg:6,368s  ereg:5,330s  EREG
pattern:'(.*) - '   preg:2,510s  ereg:5,149s  PREG
pattern:'(.*) - $'  preg:2,557s  ereg:6,699s  PREG
pattern:'ext'       preg:2,131s  ereg:2,859s  PREG
pattern:'ext$'      preg:2,195s  ereg:4,030s  PREG
pattern:'.ext'      preg:3,364s  ereg:2,981s  EREG
pattern:'.ext$'     preg:3,707s  ereg:4,296s  PREG
pattern:'(.)ext'    preg:4,426s  ereg:3,288s  EREG
pattern:'(.)ext$'   preg:5,189s  ereg:5,260s  PREG
pattern:'(.*)ext'   preg:3,226s  ereg:4,426s  PREG
pattern:'(.*)ext$'  preg:4,467s  ereg:6,570s  PREG
pattern:'[etx]+'    preg:2,394s  ereg:1,934s  EREG
pattern:'([etx]+)'  preg:2,708s  ereg:2,038s  EREG
pattern:'abc'       preg:1,771s  ereg:1,354s  EREG
pattern:'abc$'      preg:1,788s  ereg:1,353s  EREG
pattern:'.abc'      preg:4,005s  ereg:1,373s  EREG
pattern:'.abc$'     preg:3,978s  ereg:1,362s  EREG
pattern:'(.)abc'    preg:5,826s  ereg:1,381s  EREG
pattern:'(.)abc$'   preg:5,838s  ereg:1,413s  EREG
pattern:'(.*)abc'   preg:4,350s  ereg:1,393s  EREG
pattern:'(.*)abc$'  preg:4,331s  ereg:1,379s  EREG
pattern:'[abc]+'    preg:3,702s  ereg:3,310s  EREG
pattern:'([abc]+)'  preg:4,727s  ereg:3,893s  EREG
pattern:'[a-z]+'    preg:2,429s  ereg:2,022s  EREG
pattern:'([a-z]+)'  preg:2,764s  ereg:2,119s  EREG

total:  preg:109s  ereg:96s

et j'ajouterai qu'ereg a un probleme etonnant de performance dans le traitement du caractere constant '-'.

 

[medium69]

Idéalement, il faudrait testé chaque regex pour savoir quelle fonction utilisée alors :?

M'enfin, moi qui croyait qu'ereg ne faisait pas le poids ...

 

[de_prog]

je suis contente que m'on post m'est apporté autant d'info !!!

merci à vous !! tu as raison medium ;-), déjà ça me paraît au moins plus simple que le chinois mais j'ai encore du boulot pour maîtriser...

 

[medium69]

Pour revenir sur la question de la rapidité entre ereg et preg, j'apporte quelques précisions...

Pensant que cela dépendait du masque de recherche, j'ai refait plusieurs test et de tout mes test, preg est beaucoup plus rapide que ereg sauf dans un cas générique :

Si le masque n'est pas présent, alors ereg est au minimum 50% plus rapide. dans le cas contraire, preg lui rafle la mise à tous les coups !

J'ai donc gardé toutes mes regex en preg.

 

[KOogar]

Interressant de voir ces tests de rapidité, mais rien de nouveau, les fonctions PCRE (preg) ont toujours été bien plus rapide et apportent beaucoup plus d'options que les fonctions POSIX (ereg).

 

[Serious]

Interressant de voir ces tests de rapidité, mais rien de nouveau, les fonctions PCRE (preg) ont toujours été bien plus rapide

Oui, comme ces tests le montrent... tu les as regarde?

et apportent beaucoup plus d'options que les fonctions POSIX (ereg).

Ca, c'est vrai. Et aussi qqs risques de securite si elles sont mal utilisees (injection de code via //e).