Quoi de plus rapide et de meilleur pour déterminer si une clé de tableau existe en PHP?

Considérez ces 2 exemples ...

$key = 'jim';

// example 1
if (isset($array[$key])) {
    // ...
}

// example 2    
if (array_key_exists($key, $array)) {
    // ...
}

Je suis intéressé à savoir si l'un ou l'autre est meilleur. J'ai toujours utilisé le premier, mais j'ai vu beaucoup de gens utiliser le deuxième exemple sur ce site.

Alors, quel est le meilleur? Plus rapide? Une intention plus claire?

isset()est plus rapide, mais ce n'est pas la même chose que array_key_exists().

array_key_exists()vérifie uniquement si la clé existe, même si la valeur est NULL.

Considérant que isset()retournera falsesi la clé existe et la valeur est NULL.

Si vous êtes intéressé par certains tests que j'ai effectués récemment:

https://stackoverflow.com/a/21759158/520857

Résumé:

| Method Name                              | Run time             | Difference
=========================================================================================
| NonExistant::noCheckingTest()            | 0.86004090309143     | +18491.315775911%
| NonExistant::emptyTest()                 | 0.0046701431274414   | +0.95346080503016%
| NonExistant::isnullTest()                | 0.88424181938171     | +19014.461681183%
| NonExistant::issetTest()                 | 0.0046260356903076   | Fastest
| NonExistant::arrayKeyExistsTest()        | 1.9001779556274      | +209.73055713%

Eh bien, la principale différence est que isset()ne reviendra pas truepour les clés de tableau qui correspondent à une valeur nulle, contrairement array_key_exists().

L'exécution d'un petit benchmark montre que isset()c'est plus rapide, mais ce n'est peut-être pas tout à fait exact.

Je voulais ajouter mes 2 cents sur cette question, car il me manquait une solution intermédiaire.

Comme déjà dit isset(), évaluera la valeur de la clé de sorte qu'il retournera falsesi cette valeur est nulloù array_key_exists()vérifier uniquement si la clé existe dans le tableau.

J'ai exécuté un benchmark simple en utilisant PHP 7, les résultats affichés sont le temps qu'il a fallu pour terminer l'itération:

$a = [null, true];

isset($a[0])                            # 0.3258841  - false
isset($a[1])                            # 0.28261614 - true
isset($a[2])                            # 0.26198816 - false

array_key_exists(0, $a)                 # 0.46202087 - true
array_key_exists(1, $a)                 # 0.43063688 - true
array_key_exists(2, $a)                 # 0.37593913 - false

isset($a[0]) || array_key_exists(0, $a) # 0.66342998 - true
isset($a[1]) || array_key_exists(1, $a) # 0.28389215 - true
isset($a[2]) || array_key_exists(2, $a) # 0.55677581 - false

array_key_isset(0, $a)                  # 1.17933798 - true
array_key_isset(1, $a)                  # 0.70253706 - true
array_key_isset(2, $a)                  # 1.01110005 - false

J'ai également ajouté les résultats de cette fonction personnalisée avec ce benchmark pour l'achèvement:

function array_key_isset($k, $a){
    return isset($a[$k]) || array_key_exists($k, $a);
}

Comme vu et déjà dit, isset()c'est la méthode la plus rapide, mais elle peut renvoyer false si la valeur est null. Cela pourrait donner des résultats indésirables et on devrait généralement l'utiliser array_key_exists()si tel est le cas.

Cependant, il existe un moyen de sortir et qui utilise isset() || array_key_exists(). Ce code utilise généralement la fonction plus rapide isset()et si isset() renvoie false uniquement, utilisez array_key_exists()pour valider. Montré dans le tableau ci-dessus, c'est aussi rapide que d'appeler clairement isset().

Oui, c'est un peu plus de l'écrire et l'encapsuler dans une fonction est plus lent mais beaucoup plus facile. Si vous en avez besoin pour les performances, la vérification des données volumineuses, etc., écrivez-le complètement, sinon si c'est une utilisation une fois, cette surcharge très mineure en fonction array_key_isset()est négligeable.

Avec Php 7 donne la possibilité d'utiliser l' opérateur Null Coalescing .

L'opérateur de fusion nul (??) a été ajouté comme sucre syntaxique pour le cas courant de besoin d'utiliser un ternaire en conjonction avec isset (). Il renvoie son premier opérande s'il existe et n'est pas NULL; sinon, il renvoie son deuxième opérande.

Vous pouvez donc maintenant attribuer une valeur par défaut au cas où la valeur serait nulle ou si la clé n'existe pas:

$var = $array[$key] ?? 'default value'

il y a une différence avec php.net que vous lirez:

isset () ne renvoie pas TRUE pour les clés de tableau qui correspondent à une valeur NULL, contrairement à array_key_exists ().

Un test très informel se révèle array_key_exists()environ 2,5 fois plus lent queisset()

La combinaison isset()et is_null()donner les meilleures performances par rapport à d' autres fonctions telles que : array_key_exists(), isset(), isset()+ array_key_exists(), is_null(), isset()+ is_null(), la seule question ici est la fonction non seulement return false si la clé n'existe pas, mais même la clé et exist a une valeur nulle.

Script de référence:

<?php
  $a = array('a' => 4, 'e' => null)

  $s = microtime(true); 
  for($i=0; $i<=100000; $i++) { 
    $t = (isset($a['a'])) && (is_null($a['a'])); //true 
    $t = (isset($a['f'])) && (is_null($a['f'])); //false
    $t = (isset($a['e'])) && (is_null($a['e']));; //false 
  } 

  $e = microtime(true); 
  echo 'isset() + is_null() : ' , ($e-$s)."<br><br>";
?>

Crédit : http://www.zomeoff.com/php-fast-way-to-determine-a-key-elements-existance-in-an-array/

Quant à "plus rapide": essayez-le (mon argent est allumé array_key_exists(), mais je ne peux pas l'essayer pour le moment).

Quant à "plus clair dans l'intention": array_key_exists()

De toute évidence, le deuxième exemple est plus clair dans l'intention, cela ne fait aucun doute. Pour comprendre ce que fait l'exemple n ° 1, vous devez vous familiariser avec les idiosyncraties d'initialisation des variables de PHP - et vous découvrirez ensuite qu'il fonctionne différemment pour les valeurs nulles, et ainsi de suite.

Quant à savoir lequel est le plus rapide - je n'ai pas l'intention de spéculer - exécutez non plus en boucle serrée quelques centaines de milliers de fois sur votre version PHP et vous le saurez :)

Votre code isset($array[$i]) || $array[$i] === null,, retournera true dans tous les cas, même si la clé n'existe pas (et produira un avis d'index non défini). Pour les meilleures performances, ce que vous voulezif (isset($array[$key]) || array_key_exists($key,$array)){doWhatIWant();}