web-dev-qa-db-fra.com

Valeurs de falsification Javascript (chaîne nulle, non définie, fausse ou vide: "" ou '' et 0) et opérateur de comparaison (==)

Lorsque j'utilise l'une des valeurs (null, undefined, false, '', 0) dans une instruction if, elle est toujours évaluée comme une erreur (false). De plus, la négation de ces valeurs ((null, undefined, false, '', 0) dans une instruction if toujours évaluée comme tautologie (true).

 if(null){
 }else{
 }

 if(undefined){
 }else{
 }

 if(false){
 }else{
 }

 if(''){
 }else{
 }

 if(0){
 }else{
 }

Dans tous les cas ci-dessus, l'instruction if est évaluée lors de l'exécution de l'instruction false & else. Cependant, lorsque je compare ces valeurs de sophisme avec ==, il ne renvoie pas toujours true. Étonnamment, il renvoie toujours des valeurs de true lorsque je compare la négation de ces valeurs.

si double égal à (==) l'opérateur vérifie/compare les valeurs et pas strictement les types, alors pourquoi:

null == false          // returns false

null == 0              // returns false

null == ''             // returns false

Mais,

!null == !false       // returns true

!null == !0           // returns true

!false == !undefined  // returns true

Et,

null == undefined     // returns true

false == 0            // returns true

J'apprécie si quelqu'un peut clarifier le comportement ou la relation entre ces valeurs (null, undefined, false, '', 0).

javascriptnullundefined
19
Suraj Kumar

Une idée fausse commune

"... Si double égal à (==) l'opérateur vérifie/compare uniquement les valeurs et non les types ... "

C'est une hypothèse incorrecte, bien qu'elle soit souvent répétée par les gens. En réalité, le == vérifie les types et, en fait, accorde beaucoup plus d'attention aux types qu'un === la comparaison le fait.

Voir Algorithme de comparaison d'égalité abstraite.

UNE == la comparaison ne fait pas une conversion simple en booléen . Il parcourt plutôt un algorithme récursif quelque peu complexe qui, après avoir vérifié les types, tente de contraindre les opérandes au même type s'ils ne correspondent pas.

La contrainte de type qu'il effectue est très spécifique aux types d'opérandes. Une séquence différente de coercitions peut avoir lieu pour différentes paires de types. Habituellement (mais pas toujours), cela finit par contraindre les opérandes aux types number.

Pourquoi !si les opérandes changent les choses

Lorsque vous contraignez manuellement les deux opérandes à l'aide de !, vous faites maintenant une conversion simple toBoolean provoquant la correspondance des types, ce qui évite la partie coercitive de type de l'algorithme, ce qui le fait se comporter essentiellement comme le Algorithme de comparaison stricte d'égalité.

Donc, la seule façon de prédire le résultat d'un == la comparaison lorsque les types ne correspondent pas consiste à comprendre cet algorithme abstrait.

N'oubliez pas NaN

Et pour info, il y a une autre valeur "falsey" à considérer, NaN. Son == la comparaison sera toujours false, quoi qu'il arrive. Même en comparant à une autre valeur NaN, ce sera false.

15
cookie monster

undefined: signifie qu'une variable a été déclarée mais n'a pas de valeur assignée

null: la valeur de null a été affectée, ce qui signifie qu'elle n'a pas de valeur

false, '' et 0 Je pense que vous pouvez probablement comprendre ce que cela signifie.

1
Todd Motto

NULL est différent de false (NULL est de type objet et false est de type booléen), null est différent de 0 (0 est de type entier), null est également différent de '' ('' est de type chaîne). mais ce sont toutes des valeurs fausses. Le ! L'opérateur annule une valeur booléenne. Si ! est utilisé sur les valeurs de falsification, il résulte de la conversion des valeurs de falsification en un objet de type booléen.

1
Allan Chua