Comment puis-je déterminer si une variable est «non définie» ou «nulle»?

Comment déterminer si la variable est undefinedou null?

Mon code est le suivant:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Mais si je fais cela, l'interpréteur JavaScript arrête l'exécution.

Pour ce faire, vous pouvez utiliser les qualités de l' opérateur d'égalité abstraite :

if (variable == null){
    // your code here.
}

Parce que null == undefinedc'est vrai, le code ci-dessus interceptera les deux nullet undefined.

La façon standard d'attraper nullet undefinedsimultanément est la suivante:

if (variable == null) {
     // do something 
}

--qui est 100% équivalent au plus explicite mais moins concis:

if (variable === undefined || variable === null) {
     // do something 
}

Lors de la rédaction d'un JS professionnel, il est tenu pour acquis que l' égalité de type et le comportement de ==vs=== sont compris. Par conséquent, nous utilisons ==et comparons uniquement à null.

Modifier à nouveau

Les commentaires suggérant l'utilisation de typeofsont tout simplement faux. Oui, ma solution ci-dessus provoquera une ReferenceError si la variable n'existe pas. C'est une bonne chose. Cette ReferenceError est souhaitable: elle vous aidera à trouver vos erreurs et à les corriger avant d'envoyer votre code, tout comme les erreurs de compilation le feraient dans d'autres langues. Utilisez try/ catchsi vous travaillez avec une entrée sur laquelle vous n'avez aucun contrôle.

Vous ne devriez pas avoir de références à des variables non déclarées dans votre code.

En combinant les réponses ci-dessus, il semble que la réponse la plus complète serait:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Cela devrait fonctionner pour toute variable non déclarée ou déclarée et explicitement définie sur null ou non défini. L'expression booléenne doit être évaluée à false pour toute variable déclarée qui a une valeur réelle non nulle.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

sera évalué à vrai si la valeur n'est pas:

• nul

• indéfini

• NaN

• chaîne vide ("")

• 0

• faux

La attr()fonction jQuery renvoie soit une chaîne vide, soit la valeur réelle (et jamais nullou undefined). La seule fois où il revientundefined c'est lorsque votre sélecteur n'a renvoyé aucun élément.

Donc, vous voudrez peut-être tester par rapport à une chaîne vide. Alternativement, puisque les chaînes vides, null et undefined sont false-y, vous pouvez simplement faire ceci:

if (!EmpName) { //do something }

Je suis venu pour écrire ma propre fonction pour cela. JavaScript est bizarre.

Il est utilisable sur n'importe quoi. (Notez que cela vérifie également si la variable contient des valeurs utilisables . Mais puisque ces informations sont généralement également nécessaires, je pense que cela vaut la peine d'être publié). Veuillez envisager de laisser une note.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Compatible avec TypeScript.

Cette fonction doit faire exactement la même chose que la empty()fonction PHP (voirRETURN VALUES )

Considère undefined, null, false, 0, 0.0, "0" {}, []comme vide.

"0.0", NaN, " ", trueSont considérés comme non vide.

Si la variable que vous souhaitez vérifier est une variable globale, faites

if (window.yourVarName) {
    // Your code here
}

Cette façon de vérifier ne générera pas d'erreur même si la yourVarNamevariable n'existe pas.

Exemple: je veux savoir si mon navigateur prend en charge l'API Historique

if (window.history) {
    history.back();
}

Comment cela fonctionne:

windowest un objet qui contient toutes les variables globales en tant que propriétés, et en JavaScript, il est légal d'essayer d'accéder à une propriété d'objet non existante. S'il historyn'existe pas, il window.historyrevient undefined. undefinedest falsey, donc le code dans un if(undefined){}bloc ne fonctionnera pas.

Le plus court et le plus simple:

if(!EmpName ){
 // DO SOMETHING
}

cela évaluera vrai si EmpName est:

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

La façon la plus courte de procéder est probablement:

if(EmpName == null) { /* DO SOMETHING */ };

En voici la preuve:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

Et voici plus de détails sur ==(source ici )

BONUS : la raison pour laquelle ===est plus clair que ==(regardez la réponse agc )

Je viens d'avoir ce problème, c'est-à-dire de vérifier si un objet est nul.
J'utilise simplement ceci:

if (object) {
    // Your code
}

Par exemple:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Puisque vous utilisez jQuery , vous pouvez déterminer si une variable n'est pas définie ou si sa valeur est nulle en utilisant une seule fonction.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

L'élément jQuery check n'est pas nul:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

En JavaScript, à ma connaissance, nous pouvons vérifier une variable non définie, nulle ou vide comme ci-dessous.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Vérifiez toutes les conditions:

if(variable === undefined || variable === null || variable === ''){
}

Vous pouvez simplement utiliser ce qui suit (je sais qu'il existe des moyens plus courts de le faire, mais cela peut le rendre plus facile à observer visuellement, au moins pour ceux qui consultent le code).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

La façon la plus simple de vérifier est:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Avec la solution ci-dessous:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Je peux vérifier les éléments suivants:

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

Pour tester si une variable est nulle ou non définie, j'utilise le code ci-dessous.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

J'exécute ce test dans la console Chrome. En utilisant (void 0), vous pouvez cocher indéfini:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Regardons ça,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   Dans ce qui précède, la variable est uniquement déclarée comme apple. Dans ce cas, si nous appelons la méthode, alertelle s'affichera non définie.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

Dans le second, il affiche null, car la variable de applevaleur est null.

Vous pouvez donc vérifier si une valeur est indéfinie ou nulle.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Meilleur moyen:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Parce que === vérifie à la fois le type et la valeur. Le type des deux est différent mais la valeur est la même.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

La foo == nullvérification devrait faire l'affaire et résoudre le cas "non défini OU nul" de la manière la plus courte. (Ne pas considérer le cas «foo n'est pas déclaré».) Mais les gens qui ont l'habitude d'avoir 3 égaux (comme la meilleure pratique) pourraient ne pas l'accepter. Regardez simplement eqeqeq ou triple-égal règles dans eslint et tslint ...

L'approche explicite, lorsque nous vérifions si une variable est undefinedou nullséparément, doit être appliquée dans ce cas, et ma contribution au sujet (27 réponses non négatives pour l'instant!) Est d'utiliser void 0comme moyen à la fois court et sûr d'effectuer la vérification pourundefined .

L'utilisation foo === undefinedn'est pas sûre car undefined n'est pas un mot réservé et peut être masqué ( MDN ). L'utilisation de typeof === 'undefined'check est sûre, mais si nous ne nous soucions pas du cas foo-is-undeclared, l'approche suivante peut être utilisée:

if (foo === void 0 || foo === null) { ... }

si vous créez une fonction pour la vérifier:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

L'appel de typeof null renvoie une valeur d '«objet», car la valeur spéciale null est considérée comme une référence d'objet vide. Safari à travers la version 5 et Chrome à travers la version 7 ont une bizarrerie où l'appel de typeof sur une expression régulière renvoie «fonction» tandis que tous les autres navigateurs retournent «objet».

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Vous ne pouvez utiliser que le second: car il vérifiera à la fois la définition et la déclaration

Je pense toujours que le meilleur moyen / sûr de tester ces deux conditions est de convertir la valeur en chaîne:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Vous pouvez vérifier si la valeur est indéfinie ou nulle en utilisant simplement typeof:

if(typeof value == 'undefined'){

if(x==null)est une mauvaise idée en JavaScript. Jugez avec "=="- cela peut provoquer une contrainte de type inattendu, et il ne peut pas être lu par CoffeeScript, n'utilisez jamais "==" ou "! =" Dans le jugement de condition!

if(x)sera mieux, mais soyez prudent avec 0 et "" . Elle sera traitée comme fausse , et non la méthode égale à "!= null"est vraie .

Voir Meilleures pratiques JavaScript .