JavaScript, recherchant les null vs indéfini et différence entre == et ===

Question

Je sais, je sais qu’il doit y avoir quelques discussions portant sur ce sujet. Mais j’ai utilisé la recherche et n’a pas obtenu la réponse qui correspond à mes besoins. Alors nous y voilà :

1. Comment puis-je vérifier une variable s’il est null ou undefined et quelle est la différence entre les null et undefined ?
2. Quelle est la différence entre « == » et « === » (c’est dur à la recherche google pour ===) ?

Merci les gars.

Answer 1

Est la variable null:

if (a === null)
// or
if (a == null)

...mais la note de ce dernier en sera de même si a est undefined.

Est-il undefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined)

...mais encore une fois, notez que le dernier est vague; il en sera de même si a est null.

Maintenant, en dépit de ce qui précède, l' habituelle façon de vérifier pour ceux qui est d'utiliser le fait qu'ils sont falsey:

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Quelle est la différence entre == et ===: == utilise le type de coercition, de sorte "1" == 1. === ne le sont pas, "1" !== 1. De contrainte de Type utilise assez complexe de règles et peuvent avoir des résultats surprenants (par exemple, "" == 0 est vrai).

De plus, dans la spec.

Quelques expériences à jouer avec: http://jsbin.com/evowe6

Answer 2

La différence est subtile.

En JavaScript un undefined variable est une variable qui n'a jamais été déclarée, ou jamais d'attribuer une valeur. Disons que vous déclarez var a; , par exemple, a sera undefined, parce qu'il n'a jamais été attribué aucune valeur.

Mais si vous affectez ensuite a = null; alors a sera désormais null. En JavaScript null est un objet (essayez typeof null dans une console JavaScript si vous ne me croyez pas), ce qui signifie que la valeur null est une valeur (en fait, même à l' undefined est une valeur).

Exemple:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

Cela peut s'avérer utile dans les arguments de la fonction. Vous voudrez peut-être avoir une valeur par défaut, mais la considérer comme nulle pour être acceptable. Dans ce cas, vous pouvez le faire:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Si vous omettez l' optional paramètre doSomething(1, 2) thenfacultatif sera l' "three" chaîne de caractères, mais si vous passez doSomething(1, 2, null) option sera null.

Comme pour l'égalité des == et strictement égal === de comparaison, le premier est faiblement type, tandis que strictement égal vérifie également pour le type de valeurs. Cela signifie qu' 0 == "0" retournera true; while 0 === "0" retournera false, parce qu'un certain nombre n'est pas une chaîne.

Vous pouvez utiliser ces opérateurs pour vérifier entre undefined un null. Par exemple:

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

Le dernier cas est intéressant, car il permet de vérifier si une variable est soit défini ou nul et rien d'autre:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

Answer 3

La spec est l'endroit où aller pour des réponses complètes à ces questions. Voici un résumé:

1. Pour une variable x, vous pouvez:
   
   
   • vérifier si c'est null par comparaison directe à l'aide de ===. Exemple: x === null
   • vérifier si c'est undefined selon l'une des deux méthodes de base: comparaison directe avec d' undefined ou typeof. Pour diverses raisons, je préfère typeof x === "undefined".
   • vérifier si c'est l'une des null et undefined par l'aide d' == et en s'appuyant sur les légèrement arcanes règles de contrainte de type qui signifient x == null fait exactement ce que vous voulez.
     
     
2. La différence fondamentale entre == et === , c'est que si les opérandes sont de différents types, === retournera toujours false tout == permettra de convertir un ou deux opérandes dans le même type à l'aide de règles qui conduisent à certains légèrement non-intuitif comportement. Si les opérandes sont de même type (par exemple, les deux sont des chaînes de caractères, comme dans l' typeof comparaison ci-dessus), == et === se comporte exactement de la même.

Plus de lecture:

• Angus Croll de la Vérité, de l'Égalité et de JavaScript
• Andrea Giammarchi du JavaScript Coercition Démystifié
• comp.lang.javascript Faq: JavaScript de Conversion de Type

Answer 4

undefined

Il signifie que la variable n'est pas encore initialisée .

Exemple :

var x;
if(x){ //you can check like this
   //code.
}

égal(==)

Il ne vérifiez la valeur est égale pas le type de données .

Exemple :

var x = true;
var y = new Boolean(true);
x == y ; //returns true

Parce qu'il ne vérifie que la valeur .

Strict Du Signe Égal(===)

Vérifie la valeur et le type de données doit être la même .

Exemple :

var x = true;
var y = new Boolean(true);
x===y; //returns false.

Car il vérifie le type de données x est un type primitif et y est un objet boolean .

Answer 5

En ce qui concerne le # 2, je dois ajouter que == et! = Ne sont pas commutatifs et c'est quelque chose dont il faut être conscient. Je vais vous donner un exemple célèbre, mais il est facile de trouver d'autres

 false == undefined  // false
false == null       // false
null == undefined   // true  WTF