qu'est-ce qui est le plus rapide: in_array ou isset? [fermé]

Cette question est simplement pour moi car j'aime toujours écrire du code optimisé qui peut également fonctionner sur des serveurs lents bon marché (ou des serveurs avec BEAUCOUP de trafic)

J'ai regardé autour de moi et je n'ai pas pu trouver de réponse. Je me demandais ce qui est le plus rapide entre ces deux exemples en gardant à l'esprit que les clés du tableau dans mon cas ne sont pas importantes (pseudo-code naturellement):

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

Comme le point de la question n'est pas la collision de tableaux, je voudrais ajouter que si vous avez peur de heurter des insertions pour $a[$new_value], vous pouvez utiliser $a[md5($new_value)]. cela peut toujours provoquer des collisions, mais enlèverait une éventuelle attaque DoS lors de la lecture d'un fichier fourni par l'utilisateur ( http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html )

Les réponses à ce jour sont justes. L'utilisation issetdans ce cas est plus rapide car

• Il utilise une recherche de hachage O (1) sur la clé alors qu'il in_arraydoit vérifier chaque valeur jusqu'à ce qu'il trouve une correspondance.
• Étant un opcode, il a moins de surcharge que d'appeler la in_arrayfonction intégrée.

Celles-ci peuvent être démontrées en utilisant un tableau avec des valeurs (10 000 dans le test ci-dessous), ce in_arrayqui oblige à faire plus de recherche.

isset:    0.009623
in_array: 1.738441

Cela s'appuie sur le benchmark de Jason en remplissant des valeurs aléatoires et en trouvant occasionnellement une valeur qui existe dans le tableau. Tous aléatoires, alors méfiez-vous que les temps vont fluctuer.

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

Ce qui est plus rapide: isset()vsin_array()

isset() est plus rapide.

Bien que cela devrait être évident, isset()ne teste qu'une seule valeur. Alors que in_array()va itérer sur tout le tableau, en testant la valeur de chaque élément.

Une analyse comparative approximative est assez facile à utiliser microtime().

Résultats:

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

Remarque: les résultats étaient similaires, qu'ils existent ou non.

Code:

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

Ressources supplémentaires

Je vous encourage à regarder également:

• Benchmark PHP
• PHPPerf
• XDebug

L'utilisation isset()tire parti d'une recherche plus rapide car elle utilise une table de hachage , évitant ainsi le besoin de O(n)recherches.

La clé est d'abord hachée à l'aide de la fonction de hachage djb pour déterminer le compartiment de clés hachées de manière similaire dans O(1). Le compartiment est ensuite recherché de manière itérative jusqu'à ce que la clé exacte soit trouvée dans O(n).

À moins de collisions de hachage intentionnelles , cette approche donne de bien meilleures performances que in_array().

Notez que lors de l'utilisation isset()de la manière que vous avez montrée, passer les valeurs finales à une autre fonction nécessite d'utiliser array_keys()pour créer un nouveau tableau. Un compromis de mémoire peut être fait en stockant les données à la fois dans les clés et les valeurs.

Mettre à jour

Un bon moyen de voir comment vos décisions de conception de code affectent les performances d'exécution, vous pouvez consulter la version compilée de votre 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 seulement in_array()utilise une O(n)recherche relativement inefficace , mais elle doit également être appelée en tant que fonction ( DO_FCALL) alors qu'elle isset()utilise un seul opcode ( ZEND_ISSET_ISEMPTY_DIM_OBJ) pour cela.

Le second serait plus rapide, car il ne recherche que cette clé de tableau spécifique et n'a pas besoin d'itérer sur tout le tableau jusqu'à ce qu'il soit trouvé (examinera chaque élément du tableau s'il n'est pas trouvé)