Welche Methode wird strstr oder strpos bevorzugt?

Ich habe festgestellt, dass viele Entwickler sowohl strstr als auch strpos verwenden, um nach einer Teilstring-Existenz zu suchen. Wird einer von ihnen bevorzugt und warum?

Aus dem PHP- Online-Handbuch :

Wenn Sie nur feststellen möchten, ob eine bestimmte Nadel im Heuhaufen vorkommt, verwenden Sie strpos() stattdessen die schnellere und weniger speicherintensive Funktion .

Hier sind einige andere Antworten (+ Benchmarks), die ich auf meine Frage erhalten habe, die fast dieselbe ist (Ihre habe ich beim Fragen nicht erkannt).

In der Zwischenzeit meine eigenen Benchmark - Test habe ich, was ich lief 1000000 mal auch für jede relevante Funktionen ( strstr(), strpos(), stristr()und stripos()).
Hier ist der 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>';

?>

Und hier ist die erste Ausgabe, die zeigt, dass dies strpos()der Gewinner ist :

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 

Die nächste ähnelt der ersten Ausgabe ( strpos()ist wieder der Gewinner):

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

Unten ist eine andere, die interessanter ist, weil in diesem Fall strstr()der Gewinner ist:

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

Dies bedeutet, dass es wirklich von "Umgebungsbedingungen" abhängen kann , die manchmal schwer zu beeinflussen sind, und das Ergebnis solcher "Mikrooptimierungsaufgaben" ändern kann, falls Sie nur prüfen, ob eine Zeichenfolge in einer anderen vorhanden ist oder nicht.

ABER ich denke in den meisten Fällen strpos()ist der Gewinner im Vergleich zustrstr() .

Ich hoffe, dieser Test war für jemanden nützlich.

Viele Entwickler verwenden strposfür Mikrooptimierungszwecke .

Die Verwendung strstrfunktioniert auch nur, wenn die resultierende Zeichenfolge im booleschen Kontext nicht als falsch interpretiert werden kann.

strpos () erkennt, wo im Heuhaufen eine bestimmte Nadel liegt. stristr () prüft, ob sich die Nadel irgendwo im Heuhaufen befindet

Daher ist strpos () schneller und weniger speicherintensiv

ein Grund für strstr (): Wenn sich Ihre Nadel am Anfang eines Strings befindet, gibt strpos 0 zurück (müssen Sie dies also mit === false überprüfen).

Ich bevorzuge strstr()für Lesbarkeit und einfache Codierung .. strpos() !==false ist ein bisschen verwirrend ..