Null vs. False vs. in PHP
On me dit que les bons développeurs peuvent repérer/utiliser la différence entre Null et False et 0 et toutes les autres bonnes entités "rien".
Quelle est la différence, en particulier en PHP? Cela a-t-il quelque chose à voir avec ===?
C'est spécifique à la langue, mais dans PHP:
Nullsignifie " rien ". La var n'a pas été initialisée.
Falsesignifie " pas vrai dans un contexte booléen ". Utilisé pour montrer explicitement que vous avez affaire à des problèmes logiques.
0est uneint. Rien à voir avec le reste ci-dessus, utilisé pour les mathématiques.
Ce qui est délicat, c’est que dans des langages dynamiques tels que 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 ainsi l'égalité. Si vous le testez avec ===, il testera le type et vous obtiendrez une inégalité.
Alors, pourquoi sont-ils utiles?
Regardez la fonction strrpos(). Il retourne False s'il n'a rien trouvé, mais 0 s'il 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 des états:
Vous voulez faire une différence entre DebugMode = False (défini sur off), DebugMode = True (défini sur activé) et DebugMode = Null (non défini, conduira à un débogage difficile ;-)).
null est null. false est false. Triste mais vrai.
il n'y a pas beaucoup de cohérence en PHP. les développeursESSAYEZde faire null signifie "inconnu" ou "non existant". mais souvent False servira de "non-existant" (par exemple, strrpos ("fail", "search") retournera false et non null)
vous verrez souvent que null est utilisé alors qu'ils utilisent déjà false pour quelque chose. par exemple. filter_input (). Ils renvoient false si la variable échoue avec le filtre. et null si la variable n'existe pas (ne pas exister signifie qu'il a également échoué le filtre? alors pourquoi même renvoyer null?!?)
php a l'avantage de renvoyer des données dans les fonctions. et ofterter les développeurs entasser dans tout type d'état d'échec au lieu des données.
Et il n'y a pas moyen sain dans PHP de détecter les données (int, str, etc.) de l'échec (false, null)
vous devez pratiquement toujours tester === null ou === false, selon la fonction. ou pour les deux, dans des cas tels que filter_input ()/filter_var ()
et voici un peu de plaisir avec le type jongler. ne comprenant même pas les tableaux et 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)
En voici un exemple:
Comparisons of $x with PHP functions
Expression gettype() empty() is_null() isset() boolean : if($x)
$x = ""; string TRUE FALSE TRUE FALSE
$x = null; NULL TRUE TRUE FALSE FALSE
var $x; NULL TRUE TRUE FALSE FALSE
$x is undefined NULL TRUE TRUE FALSE FALSE
$x = array(); array TRUE FALSE TRUE FALSE
$x = false; boolean TRUE FALSE TRUE FALSE
$x = true; boolean FALSE FALSE TRUE TRUE
$x = 1; integer FALSE FALSE TRUE TRUE
$x = 42; integer FALSE FALSE TRUE TRUE
$x = 0; integer TRUE FALSE TRUE FALSE
$x = -1; integer FALSE FALSE TRUE TRUE
$x = "1"; string FALSE FALSE TRUE TRUE
$x = "0"; string TRUE FALSE TRUE FALSE
$x = "-1"; string FALSE FALSE TRUE TRUE
$x = "php"; string FALSE FALSE TRUE TRUE
$x = "true"; string FALSE FALSE TRUE TRUE
$x = "false"; string FALSE FALSE TRUE TRUE
Veuillez voir ceci pour plus de références de comparaisons de types en PHP. Cela devrait vous donner une compréhension claire.
Dans PHP, vous pouvez utiliser les opérateurs === et! == pour vérifier non seulement si les valeurs sont égales, mais également si leurs types correspondent. Ainsi, par exemple: 0 == false est true, mais 0 === false est false. La même chose vaut pour != versus !==. De même, si vous comparez null aux deux autres à l'aide des opérateurs mentionnés, attendez-vous à des résultats similaires.
Maintenant, dans PHP, cette qualité de valeur est généralement utilisée pour renvoyer une valeur qui peut parfois être 0 (zéro), mais il peut arriver que la fonction échoue. Dans de tels cas, dans PHP, vous renvoyez false et vous devez vérifier ces cas à l'aide de l'opérateur d'identité ===. Par exemple, si vous recherchez une position d'une chaîne dans l'autre et que vous utilisez 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 devrez en tenir compte lors du traitement du résultat.
Si vous utilisez la même technique dans vos fonctions, toute personne familiarisée avec la bibliothèque standard PHP comprendra ce qui se passe et comment vérifier si la valeur renvoyée correspond à ce qui est voulu ou si une erreur s'est produite lors du traitement. Il en va de même pour les paramètres de fonction, vous pouvez les traiter différemment selon qu’il s’agit de tableaux ou de chaînes de caractères ou non, et cette technique est également très utilisée dans PHP, ainsi tout le monde l’obtiendra facilement. Donc je suppose que c'est le pouvoir.
False, Null, Nothing, 0, Undefined , etc., etc.
Chacune de celles-ci a des significations spécifiques qui correspondent aux concepts actuels. Parfois, plusieurs significations sont surchargées dans un même mot clé ou une seule valeur.
DansCet C++ , NULL, False et 0 sont surchargés à la même valeur . Dans C # ils sont 3 concepts distincts.
null ou NULL indique généralement un manque de valeur, mais n'indique généralement pas pourquoi .0 indique le nombre naturel zéro et a une équivalence de type égale à 1, 2, 3, etc. les concepts distincts de NULL ne doivent être traités que par un nombre.
False indique une non-vérité. Et il a utilisé dans valeurs binaires . Cela ne signifie pas non défini, ni 0. Il indique simplement l'une des deux valeurs binaires.
Rien ne peut indiquer que la valeur est spécifiquement définie pour être rien qui indique la même chose que null, mais avec l'intention.
Undefined dans certaines langues indique que la valeur n'a pas encore été définie car aucun code n'a spécifié de valeur réelle.
Je viens de perdre une demi-journée à essayer d’obtenir un 0, un nul, un faux retour de strpos!
Voici tout ce que j'essayais de faire, avant de constater que la logique n'allait pas dans la bonne direction, semblant avoir un trou noir dans le codage php:
Concept Prenez un nom de domaine hébergé sur un serveur et assurez-vous que ce n'est pas au niveau racine, OK de différentes façons, mais j'ai choisi différentes en raison des autres fonctions/constructions php que j'ai réalisées.
En tout cas voici la base du cosing:
if (strpos($_SERVER ['SERVER_NAME'], dirBaseNAME ()) { do this } else {or that}
{
echo strpos(mydomain.co.uk, mydomain);
if ( strpos(mydomain, xmas) == null ) {echo "\n1 is null"; }
if ( (strpos(mydomain.co.uk, mydomain)) == 0 ) {echo "\n2 is 0"; }else {echo "\n2 Something is WRONG"; }
if ( (mydomain.co.uk, mydomain)) != 0 ) {echo "\n3 is 0"; }else {echo "\n3 it is not 0"; }
if ( (mydomain.co.uk, mydomain)) == null ) {echo "\n4 is null"; }else {echo "\n4 Something is WRONG"; }
}
FINALEMENT après avoir lu ce sujet, j'ai trouvé que cela fonctionnait !!!
{
if ((mydomain.co.uk, mydomain)) !== false )
{
echo "\n5 is True";
} else {
echo "\n5 is False";
}
}
Merci pour cet article, je comprends maintenant que même si c'est Noël, ce n'est peut-être pas Noël aussi faux, car cela peut aussi être un jour nul!
Après avoir gaspillé une journée de débogage avec un code simple, j'aurais souhaité le savoir auparavant, car je serais parvenu à identifier le problème plutôt que d'aller partout pour essayer de le faire fonctionner, alors que cela ne fonctionnait de toute façon pas aussi faux , Null et 0 ne sont pas tous les mêmes True ou False ou null?
Les différences entre ces valeurs se résument toujours à des règles détaillées spécifiques à la langue. Ce que vous apprenez pour PHP n’est pas nécessairement vrai pour Python, ou Perl, ou C, etc. Même s’il est intéressant d’apprendre les règles de la ou des langues avec lesquelles vous travaillez, vous vous en fiez trop demande des ennuis. Le problème vient du moment où le prochain programmeur doit maintenir votre code et que vous avez utilisé une construction qui tire parti de quelques détails de Null vs False (par exemple). Votre code doit avoir l’air correct (et inversement, un mauvais code doit avoir l’air faux ).
Null est utilisé dans les bases de données pour représenter "aucun enregistrement" ou "aucune information". Ainsi, vous pourriez avoir un champ de bits décrivant "cet utilisateur veut-il recevoir des courriers électroniques par nous", où Vrai veut dire qu'ils le font, Faux signifie qu'ils ne veulent rien recevoir, mais Null voudrait que vous ne le fassiez pas t sais. Ils peuvent provenir de jointures externes et autres.
Les implications logiques de Null sont souvent différentes. Dans certaines langues, NULL n’est égal à rien, donc if (a == NULL) sera toujours faux.
Donc, personnellement, j’initialisais toujours un booléen sur FALSE, et en initialiser un sur NULL serait un peu dégoûtant (même en C où les deux ne sont que 0 ... juste un truc de style).
Dans PHP, cela dépend si vous validez des types:
(
( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) &&
( false !== null ) && ( false == null )
)
Techniquement, null est 0x00 mais dans PHP ( null == 0x00 ) && ( null !== 0x00 ).
0 est une valeur entière.
Je pense que les mauvais développeurs trouvent toutes les utilisations différentes de null/0/false dans leur code.
Par exemple, l'une des erreurs les plus courantes des développeurs consiste à renvoyer un code d'erreur sous la forme de données avec une fonction.
// On error GetChar returns -1
int GetChar()
Ceci est un exemple d'interface sucre. Ceci est expliqué dans le livre "Débogage du processus de développement logiciel" et aussi dans un autre livre "écriture de code correct".
Le problème avec ceci est l'implication ou les hypothèses faites sur le type de caractère. Sur certains compilateurs, le type char peut être non signé. Ainsi, même si vous retournez -1, le compilateur peut renvoyer 1 à la place. Ces hypothèses de compilateur en C++ ou C sont difficiles à repérer.
Au lieu de cela, le meilleur moyen est de ne pas mélanger le code d'erreur avec vos données. Donc, la fonction suivante.
char GetChar()
devient maintenant
// On success return 1
// on failure return 0
bool GetChar(int &char)
Cela signifie que peu importe la jeunesse du développeur dans votre atelier de développement, il ne se trompera jamais. Bien que cela ne parle pas de redondance ou de dépendances dans le code.
Donc en général, échanger bool comme premier type de classe dans la langue est correct et je pense que joel en a parlé dans son récent postcast. Mais essayez de ne pas utiliser mix and match bools avec vos données dans vos routines et vous devriez aller parfaitement bien.
À partir de la documentation en ligne PHP :
"* Pour convertir explicitement une valeur en booléen, utilisez les transtypes (bool) ou (boolean). Cependant, dans la plupart des cas, la conversion est inutile, puisqu’une valeur est automatiquement convertie si un opérateur, une fonction ou une structure de contrôle nécessite un argument booléen . Lors de la conversion en booléen, les valeurs suivantes sont considérées comme FALSE: * Le booléen FALSE lui-même * L'entier 0 (zéro) * Le flottant 0.0 (zéro) * Le vide chaîne et la chaîne "0" * un tableau avec zéro élément * un objet avec zéro variable membre (PHP 4 uniquement) * le type spécial NULL (y compris les variables non définies) * SimpleXML objets créés à partir de balises vides Toute autre valeur est considérée comme VRAIE (y compris les ressources). * "
Donc, dans la plupart des cas, c'est la même chose.
D'autre part, le "===" et le "==" ne sont pas la même chose. Régulièrement, vous avez juste besoin de l'opérateur "égal". Clarifier:
$a == $b //Equal. TRUE if $a is equal to $b.
$a === $b //Identical. TRUE if $a is equal to $b, and they are of the same type.
Pour plus d'informations, consultez la page " Opérateurs de comparaison " dans la documentation en ligne PHP.
J'espère que cela t'aides.
Null n'est rien, False est un bit et 0 est (probablement) 32 bits.
Pas un expert PHP, mais dans certains langages plus modernes, ceux-ci ne sont pas interchangeables. J'ignore que 0 et false sont interchangeables, mais avec boolean étant un type réel, vous pouvez associer des méthodes et des objets, ce qui n'est donc qu'un compromis. Null est nul cependant, l'absence de quoi que ce soit essentiellement.
False et 0 sont conceptuellement similaires, c’est-à-dire qu’ils sont isomorphes. 0 est la valeur initiale de l'algèbre des nombres naturels et False est la valeur initiale de l'algèbre booléenne.
En d'autres termes, 0 peut être défini comme le nombre qui, ajouté à un nombre naturel, donne le même nombre:
x + 0 = x
De même, False est une valeur telle qu'une disjonction de celle-ci et de toute autre valeur est la même valeur:
x || False = x
Null est conceptuellement quelque chose de totalement différent. Selon la langue, il existe différentes sémantiques, mais aucune d'entre elles ne décrit une "valeur initiale" comme False et 0. Il n'y a pas d'algèbre pour Null. Cela concerne les variables, généralement pour indiquer que la variable n'a pas de valeur spécifique dans le contexte actuel. Dans la plupart des langages, aucune opération n'est définie sur Null et c'est une erreur d'utiliser Null en tant qu'opérande. Dans certaines langues, il existe une valeur spéciale appelée "bottom" plutôt que "null", qui est un espace réservé pour la valeur d'un calcul qui ne se termine pas.
Eh bien, je ne me souviens pas assez de mes PHP jours pour répondre à la partie "===", mais pour la plupart des langages de style C, NULL doit être utilisé dans le contexte des valeurs de pointeur, false comme booléen, et zéro en tant que valeur numérique telle qu'un int. '\ 0' est la valeur habituelle pour un contexte de caractère. Je préfère aussi généralement utiliser 0,0 pour les flotteurs et les doubles.
Alors ... la réponse rapide est: contexte.
Dans pratiquement toutes les langues modernes, null logically fait référence à des pointeurs (ou références) n'ayant pas de valeur ou à une variable non initialisée. 0 est la valeur entière égale à zéro et false, la valeur booléenne de, ainsi, false. Pour compliquer les choses, en C, par exemple, null, 0 et false sont tous représentés exactement de la même manière. Je ne sais pas comment ça marche en PHP.
Ensuite, pour compliquer davantage les choses, les bases de données ont un concept de null, ce qui signifie manquant ou non applicable, et la plupart des langues n’ont pas de moyen direct de mapper un DBNull sur leur null. Jusqu'à récemment, par exemple, il n'y avait pas de distinction entre un int égal à zéro et un zéro, mais cela a été modifié avec un int nullable.
Désolé de rendre ce son compliqué. C'est simplement que cela a été un point d'achoppement harry dans les langues pendant des années, et jusqu'à récemment, il n'y avait aucune résolution claire nulle part. Les gens avaient l'habitude de ne rien faire ensemble ou de laisser des blancs ou des zéros dans la base de données, ce qui ne fonctionne pas toujours très bien.
Quelqu'un peut m'expliquer pourquoi "NULL" n'est pas simplement une chaîne dans une instance de comparaison?
$x = 0;
var_dump($x == 'NULL'); # TRUE !!!WTF!!!
En général, les langages de programmation ont tendance à avoir des valeurs de vérité et de fausseté. Les règles régissant la vérité et la fausseté varient d’une langue à l’autre.
http://www.isolani.co.uk/blog/javascript/TruthyFalsyAndTypeCasting
Un fait intéressant à propos de NULL en PHP: Si vous définissez une variable égale à NULL, c'est comme si vous aviez appelé unset ().
NULL signifie essentiellement qu'une variable n'a pas de valeur assignée; false est une valeur booléenne valide, 0 une valeur entière valide et PHP présente une conversion assez moche entre 0, "0", "" et false.