web-dev-qa-db-fra.com

Vérification JavaScript pour null vs undefined et 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 je n'ai pas obtenu la réponse qui correspond à mes besoins. Alors on y va:

  1. Comment vérifier une variable s'il s'agit de null ou undefined et quelle est la différence entre null et undefined?

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

javascriptnullundefined
509
MUG4N

Comment vérifier une variable s'il s'agit de null ou undefined...

Est-ce que 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; cela sera également vrai si a est null.

Maintenant, malgré tout ce qui précède, la méthode habituelle de vérifier ces informations est d’utiliser le fait qu’elles 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 null et undefined?

Ce sont les deux valeurs habituellement utilisées pour indiquer l'absence de quelque chose. undefined est le plus générique, utilisé comme valeur par défaut des variables jusqu'à ce qu'on leur attribue une autre valeur, comme valeur des arguments de fonction non fournis lors de l'appel de la fonction et comme valeur que vous obtenez lorsque vous demandez à un objet pour une propriété qu'il n'a pas. Mais il peut aussi être utilisé explicitement 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 entièrement inactif.)

null est légèrement plus spécifique que undefined: il s'agit d'une référence d'objet vide. Bien sûr, JavaScript est mal typé, mais toutes les choses avec lesquelles JavaScript interagit ne sont pas mal typées. Si une API telle que le DOM dans les navigateurs nécessite une référence d'objet vide, nous utilisons null, pas undefined. De même, l'opération getElementById du DOM renvoie une référence à un objet - valide (si l'élément DOM est trouvé) ou null (si ce n'est pas le cas).

Fait intéressant (ou pas), ce sont leurs propres types. Autrement dit, null est la seule valeur du type Null et undefined est la seule valeur du type Undefined.

Quelle est la différence entre "==" et "==="

La seule différence entre eux est que == fera une contrainte de type pour essayer de faire correspondre les valeurs, et === ne le fera pas. Donc, par exemple, "1" == 1 est vrai, parce que "1" est converti en 1. Mais "1" === 1 est false, car les types ne correspondent pas. ("1" !== 1 est vrai.) La première (vraie) étape de === est "Les types des 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 == fait.

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

Plus dans le spec:

849
T.J. Crowder

La différence est subtile.

En JavaScript, une variable undefined est une variable qui n'a jamais été déclarée ni jamais assignée à une valeur. Supposons que vous déclariez var a; par exemple, alors a sera undefined, car aucune valeur ne lui a été affectée.

Mais si vous assignez 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 null est une valeur (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 fonction. Vous voudrez peut-être avoir une valeur par défaut, mais considérerez que null est acceptable. Dans ce cas, vous pouvez faire:

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

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

En ce qui concerne les comparateurs égaux == et strictement égaux ===, le premier est de type faiblement typé, alors que strictement égal vérifie également le type des valeurs. Cela signifie que 0 == "0" retournera true; tandis que 0 === "0" retournera false, car un nombre n'est pas une chaîne.

Vous pouvez utiliser ces opérateurs pour vérifier entre undefined et 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
87
Julien Portalier

La spécification est le lieu idéal pour obtenir des réponses complètes à ces questions. Voici un résumé:

  1. Pour une variable x, vous pouvez:

    • vérifiez si c'est null par comparaison directe en utilisant ===. Exemple: x === null
    • vérifiez si c'est undefined par l'une des deux méthodes de base: comparaison directe avec undefined ou typeof. Pour diverses raisons , je préfère typeof x === "undefined".
    • vérifiez s'il s'agit de l'une des null et undefined en utilisant == et en vous basant sur les règles de coercition de type légèrement obscures qui signifient que x == null fait exactement ce que vous voulez.

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

Plus de lecture:

14
Tim Down

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 à (==)

Il vérifie uniquement que la valeur est égale à pas 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 Equals (===)

Vérifie que la valeur et le type de données doivent être identiques.

Exemple :

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

Parce qu'il vérifie que le type de données x est un type primitif et que y est un objet booléen.

7
kannanrbk

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 la variable ne contient pas:

  • nul
  • undefined
  • false
  • "" (une chaîne vide)
  • NaN
2
Sumit Joshi

Si votre contrôle (logique) correspond à une négation (!) Et que vous souhaitez capturer JS null et undefined (car différents navigateurs vous donneront des résultats différents), vous utiliserez la comparaison moins restrictive: E.g .:

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

Ceci va capturer à la fois null et undefined

1
DaniDev

Vous pouvez utiliser le code ci-dessous pour vérifier les quatre (4) conditions de validation comme not null, ni vide, ni indéfini ni zéro, utilisez uniquement ce code (! (! (Variable))) en javascript et jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}

0
Ravikant

Ad 1. null n'est pas un identifiant pour une propriété de l'objet global, comme undefinedpeut être

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

Ad 2. Le === vérifie les valeurs et les types. Le == ne nécessite pas les mêmes types et effectue une conversion implicite avant la comparaison (à l'aide de .valueOf() et .toString()). Ici vous avez tous ( src ):

si

 enter image description here

== (sa négation! = )

 enter image description here

=== (sa négation! == )

 enter image description here

0
Kamil Kiełczewski