web-dev-qa-db-fra.com

Quelle méthode est préférée strstr ou strpos?

J'ai remarqué que de nombreux développeurs utilisent à la fois strstr et strpos pour vérifier l'existence d'une sous-chaîne. L'un d'eux est-il préféré et pourquoi?

phpstrposstrstr
75
danidacar

Depuis le PHP manuel en ligne :

Si vous voulez seulement déterminer si une aiguille particulière se produit dans une botte de foin, utilisez plutôt la fonction plus rapide et moins gourmande en mémoire strpos() .

116
Alnitak

Ici sont quelques autres réponses (+ repères) Je suis arrivé à ma question, qui est presque pareil (je n'ai pas réalisé le vôtre en le demandant).

En attendant, j'ai également fait mon propre test de référence, que j'ai exécuté 1000000 fois pour chaque fonction pertinente (strstr(), strpos(), stristr() et stripos()).
Voici le code:

<?php

function getmicrotime() {
    list($usec, $sec) = explode(" ", microtime());
    return ((float) $usec + (float) $sec);
}

$mystring = 'blahblahblah';  
$findme = 'bla';  

echo 'strstr & strpos TEST:<pre>';
$time_start = getmicrotime();
for($i=0; $i<1000000; $i++) strstr($mystring, $findme);
$time_needed_strstr = getmicrotime() - $time_start;
echo 'strstr():            ',
    round( $time_needed_strstr , 8 ). PHP_EOL;

$time_start = getmicrotime();
for($i=0; $i<1000000; $i++) stristr($mystring, $findme);
$time_needed_stristr = getmicrotime() - $time_start;
echo 'stristr():           ',
    round( $time_needed_stristr , 8 ) . PHP_EOL;

$time_start = getmicrotime();
for($i=0; $i<1000000; $i++) strpos($mystring, $findme) !== false;
$time_needed_strpos = getmicrotime() - $time_start;
echo 'strpos() !== false:  ',
    round( $time_needed_strpos , 8 ) . PHP_EOL;

$time_start = getmicrotime();
for($i=0; $i<1000000; $i++) stripos($mystring, $findme) !== false;
$time_needed_stripos = getmicrotime() - $time_start;
echo 'stripos() !== false: ',
    round( $time_needed_stripos , 8 ) . PHP_EOL;

echo PHP_EOL;

echo 'time_needed_stristr - time_needed_strstr: ',
     round( $time_needed_stristr - $time_needed_strstr , 8) . PHP_EOL;
echo 'time_needed_stripos - time_needed_strpos: ',
     round( $time_needed_stripos - $time_needed_strpos , 8) . PHP_EOL;

echo PHP_EOL;

echo 'time_needed_strstr  - time_needed_strpos:  ',
     round( $time_needed_strstr - $time_needed_strpos , 8) . PHP_EOL;
echo 'time_needed_stristr - time_needed_stripos: ',
     round( $time_needed_stristr - $time_needed_stripos , 8) . PHP_EOL;

echo '</pre>';

?>

Et voici la première sortie, qui montre que strpos() est le gagnant:

strstr & strpos TEST:
strstr():            2.39144707
stristr():           3.65685797
strpos() !== false:  2.39055395
stripos() !== false: 3.54681897

time_needed_stristr - time_needed_strstr: 1.2654109
time_needed_stripos - time_needed_strpos: 1.15626502

time_needed_strstr  - time_needed_strpos:  0.00089312
time_needed_stristr - time_needed_stripos: 0.110039

Le suivant est similaire à la première sortie (strpos() est à nouveau le gagnant):

strstr & strpos TEST:
strstr():            2.39969015
stristr():           3.60772395
strpos() !== false:  2.38610101
stripos() !== false: 3.34951186

time_needed_stristr - time_needed_strstr: 1.2080338
time_needed_stripos - time_needed_strpos: 0.96341085

time_needed_strstr  - time_needed_strpos:  0.01358914
time_needed_stristr - time_needed_stripos: 0.25821209

Ci-dessous, un autre, plus intéressant, car dans ce cas, strstr() est le gagnant:

strstr & strpos TEST:
strstr():            2.35499191
stristr():           3.60589004
strpos() !== false:  2.37646604
stripos() !== false: 3.51773095

time_needed_stristr - time_needed_strstr: 1.25089812
time_needed_stripos - time_needed_strpos: 1.14126492

time_needed_strstr  - time_needed_strpos:  -0.02147412
time_needed_stristr - time_needed_stripos: 0.08815908

Ça signifie cela peut vraiment dépendre des "circonstances environnementales", qui sont parfois difficiles à influencer et peuvent modifier le résultat de "tâches de micro-optimisation" comme celle-ci, au cas où vous vérifieriez simplement si une chaîne existe dans une autre ou non.

MAIS je pense que dans la plupart des cas, strpos() est le gagnant par rapport à strstr().

J'espère que ce test a été utile pour quelqu'un.

33
Sk8erPeter

De nombreux développeurs utilisent strpos à des fins micro optimisation.

L'utilisation de strstr ne fonctionne également que si la chaîne résultante ne peut pas être interprétée comme fausse dans un contexte booléen.

6
mario

strpos () détecte où se trouve une aiguille particulière dans la botte de foin. stristr () teste si l'aiguille est n'importe où dans la botte de foin

strpos () est donc plus rapide et moins gourmand en mémoire

une raison pour strstr (): si votre aiguille est au début d'une chaîne, strpos retourne 0 (alors vérifiez-la avec === false)

0
Flask