cosa è più veloce: in_array o isset? [chiuso]

Questa domanda è solo per me poiché mi piace sempre scrivere codice ottimizzato che possa essere eseguito anche su server lenti economici (o server con MOLTO traffico)

Mi sono guardato intorno e non sono riuscito a trovare una risposta. Mi chiedevo cosa sia più veloce tra questi due esempi tenendo presente che le chiavi dell'array nel mio caso non sono importanti (pseudo-codice 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
    }
}
?>

Poiché il punto della domanda non è la collisione dell'array, vorrei aggiungere che se hai paura di collidere inserti per $a[$new_value], puoi usare $a[md5($new_value)]. può ancora causare collisioni, ma eliminerebbe un possibile attacco DoS durante la lettura da un file fornito dall'utente ( http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html )

Le risposte finora sono esatte. L'utilizzo issetin questo caso è più veloce perché

• Utilizza una ricerca hash O (1) sulla chiave mentre in_arraydeve controllare ogni valore finché non trova una corrispondenza.
• Essendo un codice operativo, ha meno overhead rispetto alla chiamata della in_arrayfunzione incorporata.

Questi possono essere dimostrati utilizzando un array con valori (10.000 nel test seguente), costringendo in_arraya fare più ricerche.

isset:    0.009623
in_array: 1.738441

Questo si basa sul benchmark di Jason inserendo alcuni valori casuali e trovando occasionalmente un valore presente nell'array. Tutto casuale, quindi fai attenzione che i tempi fluttueranno.

$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;

Che è più veloce: isset()vsin_array()

isset() è più veloce.

Anche se dovrebbe essere ovvio, isset()verifica solo un singolo valore. Mentre in_array()itererà sull'intero array, testando il valore di ogni elemento.

Il benchmarking approssimativo è abbastanza facile da usare microtime().

Risultati:

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

Nota: i risultati erano simili indipendentemente dal fatto che esistessero o meno.

Codice:

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

Risorse addizionali

Ti incoraggio a guardare anche:

• Benchmark PHP
• PHPPerf
• XDebug

L'utilizzo isset()sfrutta una ricerca più rapida perché utilizza una tabella hash , evitando la necessità di O(n)ricerche.

La chiave viene prima sottoposta ad hashing utilizzando la funzione hash djb per determinare il bucket di chiavi con hash in modo simile O(1). Il bucket viene quindi cercato in modo iterativo fino a trovare la chiave esatta in O(n).

Escludendo eventuali collisioni di hash intenzionali , questo approccio offre prestazioni molto migliori rispetto a in_array().

Si noti che quando si utilizza isset()nel modo mostrato, il passaggio dei valori finali a un'altra funzione richiede l'utilizzo array_keys()per creare un nuovo array. È possibile compromettere la memoria archiviando i dati sia nelle chiavi che nei valori.

Aggiornare

Un buon modo per vedere come le decisioni di progettazione del codice influenzano le prestazioni di runtime, puoi controllare la versione compilata del tuo 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

Non solo in_array()utilizza una O(n)ricerca relativamente inefficiente , ma deve anche essere chiamata come funzione ( DO_FCALL) mentre isset()utilizza un singolo codice operativo ( ZEND_ISSET_ISEMPTY_DIM_OBJ) per questo.

Il secondo sarebbe più veloce, poiché sta cercando solo quella specifica chiave dell'array e non ha bisogno di iterare sull'intero array finché non viene trovato (esaminerà ogni elemento dell'array se non viene trovato)