preg_match() & strpos()

[thierry8]

Hello,

J'utilise une fonciton preg_match() pour vérifier si un saut de ligne est détecté, soit : preg_match('`\\r\\n`iU',$val);

Je sais que la fonction strpos() est bien plus rapide..
Si je ne m'en servais que dans une seule vérification, je n'irais pas chercher la puce, mais dans mon cas, j'en est un besoin important. Je chercher donc à gagner en performance. Bref...la question n'est pas là !

Est-il possible de vérifier un saut de ligne avec la fonction strpos() ?
Si oui comment ?

J'avais essayé cela, mais sans succès:
strpos('\r\n',$val) ou strpos("\r\n",$val) ou strpos('\\r\\n',$val) ou strpos("\\r\\n",$val)

 

[rikew]

je dit ca comme ca j'ai pas testé, mais peut être :
strpos("
",$val)

 

[ch_lensois]

t'a essayer de voir sur la reference "php.net", je pense que tu y trouvera ton bonheur

 

[mumbly]

essaye avec ca:
strpos($str,chr(10));

 

[dd32]

Si je me fie à ça, et si j'ai bien compris le problème :

<?php
  $mystring = "blablabla\r\n";
  $findme = "\r\n";
  $pos = strpos($mystring, $findme);
...
?>

Ca dépend c'est quoi $val ? c'est la valeur à trouver dans "\r\n"
ou bien plutôt tu cherches "\r\n" dans $val ?
Si c'est le 2ème cas :

strpos($val,"\r\n")

non ?

 

[thierry8]

Oui bien vue dd32.

Je l'ai remarqué aussi ! pff le boulet que je fais... :x

Et personne ne la remarqué... ça me rassure.
Je vais voir cela et vous informe.

 

[dd32]

ben, ça arrive :lol: surtout quand on manipule d'autres fonctions tournées à l'envers...

note que mumbly t'as donné un équivalent aussi :wink:

 

[thierry8]

Ok, c'est fonctionnel.

Impecc. Merci et désolé de la discussion inutile du fait de ma connerie. :? :roll:

EDIT: vi, j'ai vue, mais autant ne pas utiliser une fonction supplémentaire, en l'occurence chr(), vu que le but était de gagné en perf. Les doubles quotes fonctionne parfaitement.

 

[dd32]

pas grave... tu nous excuseras les nôtres dans d'autres cas :wink:

 

[thierry8]

J'en profite tant que j'y suis.

En terme de performance que vaut-il mieux faire pour un grand nombre d'appel au premier ou deuxième cas : (simple exemple)

    $texte = preg_replace_callback('`\[1\].+\[/1\]`iU', array($this,'test'), $texte);
    $texte = preg_replace_callback('`\[2\].+\[/2\]`iU', array($this,'test'), $texte);
    $texte = preg_replace_callback('`\[3\].+\[/3\]`iU', array($this,'test'), $texte);
    $texte = preg_replace_callback('`\[4\].+\[/4\]`iU', array($this,'test'), $texte);
    $texte = preg_replace_callback('`\[5\].+\[/5\]`iU', array($this,'test'), $texte);
    $texte = preg_replace_callback('`\[6\].+\[/6\]`iU', array($this,'test'), $texte);

OU

    //$texte = preg_replace_callback('`\[(1|2|3|4|5|6)\].+\[/(1|2|3|4|5|6)\]`', array($this,'test'), $texte);

Avec dans la fonction test la gestion de si la valeur 1 et bien égale à la valeur 2.

N'est pas la seconde qui est le plus long finalement, même si l'on ne fait appel qu'à un seul preg_replace_callback(), du fait qu'il doit comparer 1 devant pour 1|2|3|... dernière et ainsi de suite ?

Merci de votre aide et avis.

 

[thierry8]

Personne n'a une idée ?

 

[SuperPJ]

Juste une petite précision (au cas où ) : pour vérifier que "\r\n" est contenu dans $val, il ne faut pas faire :

if ( strpos($val,"\r\n") )

mais :

if ( strpos($val,"\r\n")!==false )

car si "\r\n" est en début de chaîne, ça renverra 0 ...


Sinon pour répondre à ta 2nde question, je pense que :

$texte = preg_replace_callback('`\[(1|2|3|4|5|6)\].+\[/(1|2|3|4|5|6)\]`', array($this,'test'), $texte);

est plus rapide car ca teste et remplace l'expression une seule fois tandis que dans l'autre cas ça le fait 6 fois. Je pense que c'est comme si on se demandait quel est le plus rapide entre un :

$texte = str_replace(array('a','b','c'), array('A','B','C'), $texte);

ou un :

$texte = str_replace('a', 'A', $texte);
$texte = str_replace('b', 'B', $texte);
$texte = str_replace('c', 'C', $texte);

Maintenant faut faire des boucles chronométrées pour le vérifier mais je pense que tout mettre en une seule expression c'est plus rapide malgré la complexité, d'autant que la version Perl des regexp (preg) est vraiment très performante

 

[thierry8]

Oui merci pour le "!==false". A ce niveau c'était good.

Et merci pour ton avis. C'est la solution pour laquel j'ai effectivement opté.