Quelle méthode est préférable strstr ou strpos?

Question

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

Answer 1

Du manuel en ligne de PHP:

Si vous voulez uniquement 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 ().

Answer 2

Ici sont quelques-uns des autres réponses (+critères) j'ai eu droit à ma question, qui est presque la même chose (je ne savais pas que la vôtre lors de la demande).

---

Dans l'intervalle, j'ai fait mon propre test de référence, j'ai couru 1000000 fois pour chacune des fonctions (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 le premier résultat, qui montre que l' strpos() le gagnant est:

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 

La prochaine est semblable à la première sortie (strpos() est le gagnant de nouveau):

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 en est une autre, qui est plus intéressant, parce que dans ce cas, strstr() le gagnant est:

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

Cela signifie qu'il peut vraiment dépendre de l'environnement "circonstances", qui sont parfois difficiles à influencer, et peut changer le résultat de la "micro-tâches d'optimisation", comme ceci, dans le cas où vous êtes juste de vérifier si une chaîne de caractères dans une autre ou pas.

MAIS je pense que dans la plupart des cas, strpos() est le gagnant en comparaison à d' strstr().

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

Answer 3

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

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

Answer 4

strpos () détecte où se trouve une aiguille 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 consomme moins de mémoire

une raison pour strstr (): si votre aiguille est au début d'une chaîne, strpos renvoie 0 (vous devez donc la vérifier avec === false)