Null vs Faux vs 0 en PHP

Question

On m'a dit que les bons développeurs peuvent repérer/utiliser la différence entre Null y False y 0 et toutes les autres bonnes entités "rien".
Quoi est la différence, notamment en PHP ? Est-ce que cela a quelque chose à voir avec === ?

Answer 1

Il s'agit d'un langage spécifique, mais en PHP :

Null signifie " rien ". La var n'a pas été initialisée.

False signifie " pas vrai dans un contexte booléen ". Utilisé pour montrer explicitement que l'on traite de questions logiques.

0 est un int . Rien à voir avec le reste ci-dessus, utilisé pour les mathématiques.

Maintenant, ce qui est délicat, c'est que dans les langages dynamiques comme le PHP, tous ont une valeur dans un contexte booléen qui (en PHP) est False .

Si vous le testez avec == il teste la valeur booléenne, vous obtiendrez donc une égalité. Si vous le testez avec === il testera le type, et vous obtiendrez l'inégalité.

Alors pourquoi sont-ils utiles ?

Eh bien, regardez le strrpos() fonction. Elle retourne False si elle n'a rien trouvé, mais 0 si elle a trouvé quelque chose au début de la chaîne !

<?php
// pitfall :
if (strrpos("Hello World", "Hello")) { 
    // never exectuted
}

// smart move :
if (strrpos("Hello World", "Hello") !== False) {
    // that works !
}
?>

Et bien sûr, si vous traitez avec les États :

Vous voulez faire la différence entre DebugMode = False (réglé sur off), DebugMode = True (activé) et DebugMode = Null (si elle n'est pas définie, cela entraînera un débogage difficile ;-)).

Answer 2

null es null . false es false . Triste mais vrai.

il n'y a pas beaucoup de cohérence dans PHP (bien qu'il s'améliore dans les dernières versions, il y a trop de rétrocompatibilité). Bien que la conception souhaite une certaine cohérence (décrite dans la réponse choisie ici), tout devient confus lorsque l'on considère les retours de méthodes qui utilisent les méthodes false / null de manière pas si facile à raisonner.

Vous verrez souvent que null est utilisé lorsqu'on utilise déjà false pour quelque chose. Par exemple, filter_input(). Ils renvoient false si la variable échoue au filtre, et null si la variable n'existe pas (le fait qu'elle n'existe pas signifie-t-il qu'elle a également échoué au filtre ?)

Les méthodes retournant false/null/string/etc de manière interchangeable sont un hack lorsque l'auteur se soucie du type d'échec, par exemple, avec filter_input() vous pouvez vérifier ===false o ===null si vous vous souciez de savoir pourquoi la validation a échoué. Mais si ce n'est pas le cas, cela peut être un piège, car on peut oublier d'ajouter la vérification de la présence de ===null s'ils se souvenaient seulement d'écrire le cas de test pour ===false . Et la plupart des outils de test unitaire/couverture de php n'attireront pas votre attention sur le chemin de code manquant et non testé !

Enfin, voici un peu d'amusement avec la jonglerie des types, sans même inclure les tableaux ou les objets.

var_dump( 0<0 );        #bool(false)
var_dump( 1<0 );        #bool(false)
var_dump( -1<0 );       #bool(true)
var_dump( false<0 );    #bool(false)
var_dump( null<0 );     #bool(false)
var_dump( ''<0 );       #bool(false)
var_dump( 'a'<0 );      #bool(false)
echo "\n";
var_dump( !0 );        #bool(true)
var_dump( !1 );        #bool(false)
var_dump( !-1 );       #bool(false)
var_dump( !false );    #bool(true)
var_dump( !null );     #bool(true)
var_dump( !'' );       #bool(true)
var_dump( !'a' );      #bool(false)
echo "\n";
var_dump( false == 0 );        #bool(true)
var_dump( false == 1 );        #bool(false)
var_dump( false == -1 );       #bool(false)
var_dump( false == false );    #bool(true)
var_dump( false == null );     #bool(true)
var_dump( false == '' );       #bool(true)
var_dump( false == 'a' );      #bool(false)
echo "\n";
var_dump( null == 0 );        #bool(true)
var_dump( null == 1 );        #bool(false)
var_dump( null == -1 );       #bool(false)
var_dump( null == false );    #bool(true)
var_dump( null == null );     #bool(true)
var_dump( null == '' );       #bool(true)
var_dump( null == 'a' );      #bool(false)
echo "\n";
$a=0; var_dump( empty($a) );        #bool(true)
$a=1; var_dump( empty($a) );        #bool(false)
$a=-1; var_dump( empty($a) );       #bool(false)
$a=false; var_dump( empty($a) );    #bool(true)
$a=null; var_dump( empty($a) );     #bool(true)
$a=''; var_dump( empty($a) );       #bool(true)
$a='a'; var_dump( empty($a));      # bool(false)
echo "\n"; #new block suggested by @thehpi
var_dump( null < -1 ); #bool(true)
var_dump( null < 0 ); #bool(false)
var_dump( null < 1 ); #bool(true)
var_dump( -1 > true ); #bool(false)
var_dump( 0 > true ); #bool(false)
var_dump( 1 > true ); #bool(true)
var_dump( -1 > false ); #bool(true)
var_dump( 0 > false ); #bool(false)
var_dump( 1 > true ); #bool(true)

Answer 3

Faux, Nul, Rien, 0, Indéfini etc., etc.

Chacun d'entre eux a des significations spécifiques qui correspondent à des concepts réels. Parfois, plusieurs significations sont surchargées dans un seul mot-clé ou une seule valeur.

Sur C y C++ , NULL , False y 0 sont surchargés à la même valeur. Dans C# ce sont 3 concepts distincts.

null o NULL indique généralement un manque de valeur, mais ne précise généralement pas pourquoi. 0 indique le nombre naturel zéro et a l'équivalence de type avec 1, 2, 3, etc. et dans les langages qui prennent en charge des concepts distincts de NULL ne doit être traité que comme un numéro.

Faux indique la non-vérité. Et il est utilisé dans valeurs binaires . Cela ne signifie pas "unset", ni "unset", ni "unset". 0 . Il indique simplement une des deux valeurs binaires.

Rien peut indiquer que la valeur est spécifiquement définie pour être rien, ce qui indique la même chose que null, mais avec intention.

Undefined dans certains langages indique que la valeur n'a pas encore été définie car aucun code n'a spécifié une valeur réelle.

Answer 4

En PHP, vous pouvez utiliser les opérateurs === et !== pour vérifier non seulement si les valeurs sont égales mais aussi si leurs types correspondent. Ainsi, par exemple 0 == false es true mais 0 === false es false . Il en va de même pour != contre !== . En outre, si vous comparez null aux deux autres en utilisant les opérateurs mentionnés, attendez-vous à des résultats similaires.

Maintenant, en PHP, cette qualité de valeurs est généralement utilisée pour retourner une valeur qui peut parfois être 0 (zéro), mais parfois il se peut que la fonction ait échoué. Dans ce cas, en PHP, vous retournez false et vous devez vérifier ces cas en utilisant l'opérateur d'identité === . Par exemple, si vous recherchez la position d'une chaîne de caractères à l'intérieur d'une autre et que vous utilisez la fonction strpos() cette fonction renverra la position numérique qui peut être 0 si la chaîne est trouvée au tout début, mais si la chaîne n'est pas trouvée du tout, alors strpos() retournera false et vous devez en tenir compte lorsque vous traitez le résultat.

Si vous utilisez la même technique dans vos fonctions, toute personne familiarisée avec la bibliothèque PHP standard comprendra ce qui se passe et comment vérifier si la valeur renvoyée correspond à ce qui est souhaité ou si une erreur s'est produite lors du traitement. Il en va de même pour les paramètres des fonctions, vous pouvez les traiter différemment selon qu'il s'agit de tableaux, de chaînes ou autres, et cette technique est utilisée dans tout PHP, donc tout le monde la comprendra facilement. Donc je pense que c'est ça la puissance.

Answer 5

Les différences entre ces valeurs se résument toujours à des règles détaillées propres au langage. Ce que vous apprenez pour PHP n'est pas nécessairement vrai pour Python, ou Perl, ou C, etc. Bien qu'il soit utile d'apprendre les règles du ou des langages avec lesquels vous travaillez, s'y fier trop souvent est une source d'ennuis. Les problèmes surviennent lorsque le prochain programmeur doit maintenir votre code et que vous avez utilisé une construction qui tire profit d'un petit détail de Null vs False (par exemple). Votre code doit sembler correct (et inversement, un code erroné doit avoir l'air erroné ).