Question JavaScript vérifiant la valeur null vs non définie et la différence entre == et ===


Je sais, je sais qu'il doit y avoir des discussions sur ce sujet. Mais j'ai utilisé la recherche et n'ai pas obtenu la réponse qui correspond à mes besoins. Alors on y va:

  1. Comment puis-je vérifier une variable si elle est null ou undefined et quelle est la différence entre le null et undefined?

  2. Quelle est la différence entre "==" et "===" (il est difficile de chercher Google pour === )?


478
2018-02-24 08:10


origine


Réponses:


Comment puis-je vérifier une variable si elle est null ou undefined...

Est la variable null:

if (a === null)
// or
if (a == null) // but see note below

... mais notez que ce dernier sera également vrai si a est undefined.

Est-ce undefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... mais encore une fois, notez que le dernier est vague; ce sera aussi vrai si a est null.

Maintenant, malgré ce qui précède, le habituel  moyen de vérifier pour ceux-ci 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`)
}

Ceci est défini par ToBoolean dans la spécification

... et quelle est la différence entre le null et undefined?

Ils sont généralement les deux valeurs utilisées pour indiquer l'absence de quelque chose. undefined est la plus générique, utilisée comme valeur par défaut des variables jusqu'à ce qu'elles reçoivent une autre valeur, comme la valeur des arguments de fonction qui n'ont pas été fournis lors de l'appel de la fonction et comme valeur obtenue lorsque vous demandez un objet pour une propriété, il n'a pas. Mais il peut aussi être explicitement utilisé dans toutes ces situations. (Il y a une différence entre un objet n'ayant pas de propriété et la propriété avec la valeur undefined; il y a une différence entre appeler une fonction avec la valeur undefined pour un argument, et laisser cet argument complètement.)

null est légèrement plus spécifique que undefined: C'est une référence d'objet vide. JavaScript est bien typé, bien sûr, mais toutes les choses avec lesquelles JavaScript interagit ne sont pas typées. Si une API comme le DOM dans les navigateurs a besoin d'une référence d'objet vide, nous utilisons null, ne pas undefined. Et de même, les DOM getElementById opération renvoie une référence d'objet - soit une référence valide (si elle a trouvé l'élément DOM), soit null (si ce n'était pas le cas).

Intéressant (ou pas), ils sont leurs propres types. C'est-à-dire, null est la seule valeur du type Null, et undefined est la seule valeur du type Undefined.

Quelle est la difference entre "==" et "==="

La seule différence entre eux est que == fera taper la coercition pour essayer d'obtenir les valeurs à faire correspondre, et === habitude. Ainsi par exemple "1" == 1 est vrai, parce que "1" coerces à 1. Mais "1" === 1 est faux, car les types ne correspondent pas. ("1" !== 1 est vrai.) La première étape (réelle) de === est "Les types d'opérandes sont-ils les mêmes?" et si la réponse est "non", le résultat est false. Si les types sont les mêmes, il fait exactement ce que == Est-ce que.

La coercition de type utilise des règles assez complexes et peut avoir des résultats surprenants (par exemple, "" == 0 est vrai).

Plus dans la spécification:


801
2018-02-24 08:15



La différence est subtile.

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

Mais si vous attribuez ensuite a = null; puis a sera maintenant null. En JavaScript null est un objet (essayez typeof null dans une console JavaScript si vous ne me croyez pas), ce qui signifie que null est une valeur (en fait même 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 considérer que null est acceptable. Dans quel cas vous pouvez faire:

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

Si vous omettez le optional paramètre doSomething(1, 2) thenoptionnel sera le "three" chaîne mais si vous passez doSomething(1, 2, null) alors facultatif sera null.

Quant à l'égalité == et strictement égal === les comparateurs, le premier est faiblement typé, alors que strictement égal vérifie également le type de valeurs. Cela signifie que 0 == "0" va retourner vrai; tandis que 0 === "0" retournera false, car un nombre n'est pas une chaîne.

Vous pouvez utiliser ces opérateurs pour vérifier 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 vous permet de vérifier si une variable est indéfinie ou nulle et rien d’autre:

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

83
2017-10-02 12:20



La spécification est l'endroit où aller pour obtenir 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 en utilisant ===. Exemple: x === null
    • vérifier si c'est undefined par l'une des deux méthodes de base: comparaison directe avec undefined ou typeof. Pour raisons diverses, Je préfère typeof x === "undefined".
    • vérifier si c'est l'un des null et undefined en utilisant == et en s'appuyant sur les règles de coercition de type légèrement arcanes qui signifient x == null fait exactement ce que vous voulez.

  2. La différence fondamentale entre == et === est-ce que si les opérandes sont de différents types, === reviendra toujours false tandis que == convertira un ou les deux opérandes dans le même type en utilisant règles cela conduit à un comportement légèrement non intuitif. Si les opérandes sont du même type (par exemple, les deux sont des chaînes, comme dans le typeof comparaison ci-dessus), == et === se comportera exactement la même chose.

Plus de lecture:


14
2017-10-04 09:32



indéfini

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

Exemple :

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

est égal à (==)

La seule valeur de contrôle est égale à non 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.

Stricts égaux (===)

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

Exemple :

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

Comme il vérifie le type de données x est un type primitif et y est un objet booléen.


7
2017-10-03 17:36



Si votre vérification (logique) concerne une négation (!) Et que vous souhaitez capturer à la fois JS null et undefined(comme différents navigateurs vous donneront des résultats différents) vous utiliserez la comparaison moins restrictive: par exemple.:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

Cela va capturer à la fois null et undefined


0
2018-03-03 18:26



Comment vérifier une variable si elle est nulle ou non définie

il suffit de vérifier si une variable a une valeur valide comme ceci:

if(variable)

il retournera true si variable ne contient pas:

  • nul
  • indéfini
  • 0
  • faux
  • "" (une chaîne vide)
  • NaN

-1
2017-08-04 13:14



Si vous voulez vérifier pour null ou undefined mais ne vous fiez pas à la simple fausseté, vous pouvez également utiliser cette composant is-nil réutilisable qui détermine si val la référence est nulle ou non définie.

Exemples:

isNil(null) // => true
isNil('') // => true

Pour une chaîne vide, par exemple, elle retournera false.


-3
2018-06-05 08:46