JavaScript vérifiant la valeur nulle par rapport à non définie et la différence entre == et ===

1. Comment vérifier une variable si c'est nullou undefinedet quelle est la différence entre le nullet undefined?

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

Comment vérifier une variable si c'est nullou undefined...

La variable est-elle null:

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

... mais notez que ce dernier sera également vrai s'il l' aest 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 également vrai si tel aest le cas null.

Maintenant, malgré ce qui précède, la façon habituelle de vérifier ces derniers 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 nullet undefined?

Ce sont deux valeurs généralement utilisées pour indiquer l'absence de quelque chose. undefinedest la plus générique, utilisée comme valeur par défaut des variables jusqu'à ce qu'elles reçoivent une autre valeur, comme valeur des arguments de fonction qui n'étaient pas 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 également être explicitement utilisé dans toutes ces situations. (Il y a une différence entre un objet qui n'a 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 undefinedd'un argument et laisser cet argument complètement.)

nullest légèrement plus spécifique que undefined: C'est une référence d'objet vide. JavaScript est typé de manière lâche, bien sûr, mais toutes les choses avec lesquelles JavaScript interagit ne sont pas typées de manière lâche. Si une API comme le DOM dans les navigateurs a besoin d'une référence d'objet vide, nous l'utilisons null, non undefined. De même, l' getElementByIdopération du DOM 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'est pas le cas).

Fait intéressant (ou non), ce sont leurs propres types. C'est-à-dire, nullest la seule valeur dans le type Null, et undefinedest la seule valeur dans le type Undefined.

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

La seule différence entre eux est que ==cela forcera le type à essayer d'obtenir les valeurs correspondantes, et ===ne le fera pas. Ainsi, par exemple, "1" == 1est vrai, car "1"contraint à 1. Mais "1" === 1c'est faux , car les types ne correspondent pas. ( "1" !== 1est vrai.) La première (vraie) étape ===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 qui ==fait.

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

Plus dans la spécification:

• Comparaison d'égalité abstraite ( ==, également appelée égalité "lâche")
• Comparaison stricte d'égalité ( ===)

La différence est subtile.

En JavaScript, une undefinedvariable est une variable qui n'a jamais été déclarée ou n'a jamais affecté de valeur. Disons que vous déclarez var a;par exemple, ce asera le cas undefined, car aucune valeur ne lui a été affectée.

Mais si vous attribuez a = null;alors, ce asera désormais le cas null. En JavaScript nullest un objet (essayez typeof nulldans une console JavaScript si vous ne me croyez pas), ce qui signifie que null est une valeur (en fait même undefinedest 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 pouvez vouloir avoir une valeur par défaut, mais considérez null comme acceptable. Dans ce cas, vous pouvez faire:

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

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

Quant aux comparateurs égaux ==et strictement égaux ===, le premier est de type faible, tandis que strictement égal vérifie également le type de valeurs. Cela signifie que 0 == "0"cela reviendra vrai; while 0 === "0"renverra false, car un nombre n'est pas une chaîne.

Vous pouvez utiliser ces opérateurs pour vérifier entre undefinedun 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 indéfinie, soit nulle et rien d'autre:

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

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 nullpar comparaison directe avec ===. Exemple:x === null
   • vérifier si c'est undefinedpar l'une des deux méthodes de base: comparaison directe avec undefinedou typeof. Pour diverses raisons , je préfère typeof x === "undefined".
   • Vérifiez s'il s'agit de l'une des règles de coercition de type légèrement arcanes nullet undefineden les utilisant ==et en vous appuyant sur elles, ce qui signifie x == nullexactement ce que vous voulez.
     
     
2. La différence fondamentale entre ==et ===est que si les opérandes sont de types différents, ===retournera toujours falsewhile ==convertira un ou les deux opérandes dans le même type en utilisant des règles qui conduisent à 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 typeofcomparaison ci-dessus), ==et ===se comporteront exactement de la même manière.

Plus de lecture:

• Angus Croll's Truth, Equality and JavaScript
• La coercition JavaScript d' Andrea Giammarchi démystifiée
• FAQ comp.lang.javascript: Conversion de type JavaScript

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

vérifiez simplement si une variable a une valeur valide comme celle-ci:

if(variable)

il retournera vrai si la variable ne contient pas:

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

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 le type de données.

Exemple :

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

Parce qu'il vérifie uniquement 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 y est un objet booléen.

L'annonce 1. nulln'est pas un identifiant pour une propriété de l'objet global, comme undefined peut l'ê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');

Annonce 2. Les ===valeurs et types de contrôle. Ils ==ne nécessitent pas les mêmes types et ont effectué une conversion implicite avant la comparaison (en utilisant .valueOf()et .toString()). Ici, vous avez tout ( src ):

si

== (sa négation ! = )

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

Si votre vérification (logique) est pour une négation (!) Et que vous souhaitez capturer à la fois JS nullet undefined (comme différents navigateurs vous donneront des résultats différents), vous utiliseriez la comparaison moins restrictive: par exemple:

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

Cela capturera à la fois nulletundefined

Essayez avec une logique différente . Vous pouvez utiliser le code ci-dessous pour vérifier les quatre (4) conditions de validation comme non nul, non vide, non indéfini et non nul uniquement utiliser 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);
}

}