una - strstr php

¿Qué método es preferido strstr o strpos?

Question

Noté que muchos desarrolladores están usando strstr y strpos para verificar la existencia de una subcadena. Es uno de ellos preferido y por qué?

Answer 1

Del manual en línea de PHP:

Si solo desea determinar si una aguja en particular se encuentra dentro de un pajar, utilice en su lugar la función más rápida y menos intensiva de memoria strpos ().

Answer 2

Muchos desarrolladores usan strpos para fines de micro optimización .

El uso de strstr también solo funciona si la cadena resultante no se puede interpretar como falsa en el contexto booleano.

Answer 3

Prefiero strstr() para la legibilidad y la codificación fácil ... strpos() !==false confunde un poco ...

Answer 4

strpos () detecta en qué parte del pajar se encuentra una aguja en particular. stristr () prueba si la aguja está en algún lugar del pajar

por lo tanto strpos () es más rápido y consume menos memoria

una razón para strstr (): si su aguja está al principio de una cadena, strpos devuelve 0 (por lo que debe verificarlo con === falso)

Answer 5

Here hay algunas otras respuestas (+ puntos de referencia). Llegué a mi pregunta, que es casi la misma (no me di cuenta de la suya al preguntar).

Mientras tanto, también hice mi propia prueba de referencia, que ejecuté 1000000 veces para cada función relevante ( strstr() , strpos() , stristr() y stripos() ).
Aquí está el código:

<?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>'';

?>

Y aquí está la primera salida, que muestra que strpos() es el ganador :

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 

El siguiente es similar al primer resultado ( strpos() es el ganador de nuevo):

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

A continuación hay otro, que es más interesante, porque en este caso, strstr() es el ganador:

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

Esto significa que realmente puede depender de "circunstancias ambientales" , que a veces son difíciles de influenciar, y puede cambiar el resultado de "tareas de micro optimización" como esta, en caso de que solo esté comprobando si una cadena existe en otra o no.

PERO creo que en la mayoría de los casos, strpos() es el ganador en comparación con strstr() .

Espero que esta prueba sea útil para alguien.