¿Qué es más rápido: in_array o isset? [cerrado]

Esta pregunta es solo para mí, ya que siempre me gusta escribir código optimizado que pueda ejecutarse también en servidores lentos y baratos (o servidores con MUCHO tráfico)

Miré a mi alrededor y no pude encontrar una respuesta. Me preguntaba qué es más rápido entre esos dos ejemplos teniendo en cuenta que las claves de la matriz en mi caso no son importantes (pseudocódigo, naturalmente):

<?php
$a = array();
while($new_val = 'get over 100k email addresses already lowercased'){
    if(!in_array($new_val, $a){
        $a[] = $new_val;
        //do other stuff
    }
}
?>

<?php
$a = array();
while($new_val = 'get over 100k email addresses already lowercased'){
    if(!isset($a[$new_val]){
        $a[$new_val] = true;
        //do other stuff
    }
}
?>

Como el punto de la pregunta no es la colisión de la matriz, me gustaría agregar que si tiene miedo de colisionar las inserciones $a[$new_value], puede usar $a[md5($new_value)]. aún puede causar colisiones, pero evitaría un posible ataque DoS al leer un archivo proporcionado por el usuario ( http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html )

Las respuestas hasta ahora son acertadas. Usar isseten este caso es más rápido porque

• Utiliza una búsqueda de hash O (1) en la clave, mientras que in_arraydebe verificar cada valor hasta encontrar una coincidencia.
• Al ser un código de operación, tiene menos gastos generales que llamar a la in_arrayfunción incorporada.

Estos se pueden demostrar usando una matriz con valores (10,000 en la prueba a continuación), lo in_arrayque obliga a realizar más búsquedas.

isset:    0.009623
in_array: 1.738441

Esto se basa en el punto de referencia de Jason al completar algunos valores aleatorios y, ocasionalmente, encontrar un valor que exista en la matriz. Todo al azar, así que ten cuidado con los tiempos que fluctúan.

$a = array();
for ($i = 0; $i < 10000; ++$i) {
    $v = rand(1, 1000000);
    $a[$v] = $v;
}
echo "Size: ", count($a), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    isset($a[rand(1, 1000000)]);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    in_array(rand(1, 1000000), $a);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

Cuál es más rápido: isset()vsin_array()

isset() es más rápido.

Si bien debería ser obvio, isset()solo prueba un valor único. Considerando in_array()que iterará sobre toda la matriz, probando el valor de cada elemento.

La evaluación comparativa aproximada es bastante fácil de usar microtime().

Resultados:

Total time isset():    0.002857
Total time in_array(): 0.017103

Nota: Los resultados fueron similares independientemente de si existían o no.

Código:

<?php
$a = array();
$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    isset($a['key']);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    in_array('key', $a);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

exit;

Recursos adicionales

Te animo a que también mires:

• Benchmark de PHP
• PHPPerf
• XDebug

El uso isset()aprovecha una búsqueda más rápida porque usa una tabla hash , evitando la necesidad de O(n)búsquedas.

La clave se hash primero usando la función hash djb para determinar el grupo de claves con hash similar en O(1). Luego, se busca en el depósito de forma iterativa hasta que se encuentra la clave exacta O(n).

Salvo cualquier colisión de hash intencionada , este enfoque produce un rendimiento mucho mejor que in_array().

Tenga en cuenta que cuando se usa isset()de la manera que ha mostrado, pasar los valores finales a otra función requiere usar array_keys()para crear una nueva matriz. Se puede comprometer la memoria almacenando los datos tanto en las claves como en los valores.

Actualizar

Una buena forma de ver cómo las decisiones de diseño de su código afectan el rendimiento en tiempo de ejecución, puede consultar la versión compilada de su script:

echo isset($arr[123])

compiled vars:  !0 = $arr
line     # *  op                           fetch      ext  return  operands
-----------------------------------------------------------------------------
   1     0  >   ZEND_ISSET_ISEMPTY_DIM_OBJ              2000000  ~0      !0, 123
         1      ECHO                                                 ~0
         2    > RETURN                                               null

echo in_array(123, $arr)

compiled vars:  !0 = $arr
line     # *  op                           fetch      ext  return  operands
-----------------------------------------------------------------------------
   1     0  >   SEND_VAL                                             123
         1      SEND_VAR                                             !0
         2      DO_FCALL                                 2  $0      'in_array'
         3      ECHO                                                 $0
         4    > RETURN                                               null

No solo in_array()usa una O(n)búsqueda relativamente ineficiente , también necesita ser llamada como una función ( DO_FCALL) mientras que isset()usa un solo código de operación ( ZEND_ISSET_ISEMPTY_DIM_OBJ) para esto.

El segundo sería más rápido, ya que solo busca esa clave de matriz específica y no necesita iterar sobre toda la matriz hasta que se encuentre (mirará cada elemento de la matriz si no se encuentra)