is_null($x) vs $x === null en PHP

Question

Duplicata possible :
Quelle est la différence entre is_null($var) et ($var === null) ?

PHP en a deux (à ma connaissance, et trois si vous comptez les isset() ) pour déterminer si une valeur est nulle : is_null() y === null . J'ai entendu, mais pas confirmé, que === null est plus rapide, mais lors d'une revue de code, quelqu'un m'a fortement suggéré d'utiliser is_null() à la place, car il est spécifiquement conçu pour l'objectif de l'évaluation nulle. Il a aussi commencé à parler de mathématiques ou quelque chose comme ça.

Quoi qu'il en soit, le fait que is_null() est apparemment plus lente me pousse à croire qu'elle fait plus que === null le fait et est probablement préféré. Y a-t-il une raison d'utiliser l'un ou l'autre ? L'une d'elles est-elle toujours préférable ? Qu'en est-il de isset() ?

En guise d'addendum pour que cette question ne soit pas fermée, que diriez-vous de isset() vs. is_null() ? Il semble que tous isset() supprimera l'avis, donc à moins que vous n'ayez réellement veulent un avis pour une variable non définie, une raison quelconque d'utiliser is_null() à la place ? Et si vous savez que la variable est initialisée à ce moment-là ?

Enfin, y a-t-il une raison mathématique pour préférer is_null() sur === null ? Quelque chose à propos de la nullité qui n'est pas comparable ?

Answer 1

Il y a absolument pas différence de fonctionnalité entre is_null y === null .

La seule différence est que is_null est une fonction et donc

1. est marginalement plus lent (surcharge des appels de fonction)
2. peut être utilisé comme un callback, par ex. array_map('is_null', $array) .

Personnellement, j'utilise null === chaque fois que je le peux, car cela est plus cohérent avec false === y true === des contrôles.

Si vous voulez, vous pouvez vérifier le code : is_identical_function ( === ) et php_is_type ( is_null ) font la même chose pour le IS_NULL cas.

---

Les isset() La construction du langage vérifie si la variable existe réellement avant d'effectuer l'opération. null vérifier. Donc isset($undefinedVar) ne lancera pas un avis.

Notez également que isset() peuvent parfois revenir true même si la valeur est null - c'est le cas lorsqu'elle est utilisée sur un objet surchargé, c'est-à-dire si l'objet définit une fonction offsetExists / __isset qui renvoie true même si le décalage est null (c'est en fait assez courant, parce que les gens utilisent array_key_exists en offsetExists / __isset ).

Answer 2

Comme d'autres l'ont dit, il y a une différence de temps entre l'utilisation de la === y is_null() . J'ai fait quelques tests rapides et j'ai obtenu les résultats suivants :

<?php

//checking with ===
$a = array();
$time = microtime(true);
for($i=0;$i<10000;$i++) {
    if($a[$i] === null) {
         //do nothing
    }
}
echo 'Testing with === ', microtime(true) - $time, "\n";

//checking with is_null()
$time = microtime(true);
for($i=0;$i<10000;$i++) {
    if(is_null($a[$i])) {
         //do nothing
    }
}
echo 'Testing with is_null() ', microtime(true) - $time;
?>

Donne les résultats

Test avec === 0.0090668201446533

Test avec is_null() 0.013684034347534

Voir le code en action

Answer 3

Elles ont toutes leur place, bien que seule isset() permette d'éviter les avertissements de variable indéfinie :

$ php -a
Interactive shell

php > var_dump(is_null($a));
PHP Notice:  Undefined variable: a in php shell code on line 1
bool(true)
php > var_dump($a === null);
PHP Notice:  Undefined variable: a in php shell code on line 1
bool(true)
php > var_dump(isset($a));
bool(false)
php >

Answer 4

Vous devez isset() si la variable est éventuellement non définie. Elle renvoie false lorsque la variable n'est pas définie ou === null (oui, c'est que moche). Seulement isset() y empty() ne pas lever un E_NOTICE si la variable ou l'élément du tableau n'existe pas.

Il n'y a pas vraiment de différence entre is_null y === null . Je pense === est beaucoup plus agréable, mais lorsque vous avez besoin d'utiliser, par exemple, l'option call_user_func pour une raison douteuse, il faudrait utiliser is_null .

Answer 5

=== y is_null est le même.

Selon ce commentaire is_null est seulement 250ns plus lent. Je pense que c'est parce qu'une fonction est plus lente qu'un opérateur.