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


2131

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.


Réponses:


2851

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.


5
J'essaie de tester si l'événement est nul dans Firefox et une erreur bloque l'exécution: "l'événement n'est pas défini"
Entretoize

3
@MichaelFever Comment ça ne marche pas? Copiez collez ceci dans votre console: const y = undefined; y == null;Il devrait revenirtrue
Seraf

2
@ChrisStryczynski Dans l'exemple de votre commentaire, vous avez déclaré yconstant, mais vous avez comparé abc(pas y). Lorsque j'ai testé yvia console.log(y == null);Chrome et Firefox, j'ai obtenu truele résultat. Si vous avez une erreur, vous avez peut-être essayé d'utiliser l'opérateur d'affectation =au lieu de la comparaison, ==ce qui aurait du sens de renvoyer l'erreur car constne peut pas être réaffecté.
Pshemo

2
exemple en direct de comparaisons pertinentes. lgtm.
Ryan Haining

2
@ZaytsevDmitry pourquoi vous attendriez-vous à un test si une variable est nullou undefinedà passer si la variable est égale 0? La question n'est pas de tester une valeur véridique, mais plutôt de tester explicitement pour nullou undefined.
rodrigo-silveira

1108

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.


47
Cela provoquera une ReferenceError et interrompra l'exécution si la variable n'est pas définie ou référencée du tout dans le code, l'utilisation de typeof est plus sûre.
Mani Gandham

56
C'est plus un point stylistique. Si la variable n'a pas été déclarée du tout , c'est vraiment juste une mauvaise écriture de la part de l'auteur. Vous devez savoir si votre variable a été déclarée ou non, cela ne devrait pas être une question. Mais oui , si pour une raison quelconque, c'est le cas, cela devrait être changé en window.variable au lieu de simplement variable , ce qui ne provoquera pas d'erreur de référence. Le type doit être évité.
temporaire_user_name

6
Oui parce que tu as écrit !==au lieu de !=.
temporaire_user_name

9
-OP: La déclaration selon laquelle ces comparaisons sont "100% équivalentes" est SIMPLEMENT ERRONÉE, comme vous l'avez noté dans votre propre EDIT, la seconde provoquera une ReferenceError. Quant à l'assertion: "Vous ne devriez pas avoir de références à des variables non déclarées dans votre code." VRAIMENT? Avez-vous déjà entendu parler des paramètres facultatifs? jsfiddle.net/3xnbxfsu
Timothy Kanski

16
Les paramètres facultatifs de @TimothyKanski peuvent être indéfinis s'ils ne sont facultativement pas fournis, mais il s'agit très certainement de variables déclarées. Ils sont déclarés et ont une valeur de undefined, comme le ferait toute variable déclarée mais non initialisée, c'est-à-dire var someVar;que votre argument ne tient pas vraiment
chiliNUT

228

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.


2
@Aerovistae Je reconnais que typeofc'est un opérateur, pas une fonction, donc il n'a pas besoin des parenthèses, mais j'apprécie néanmoins les parenthèses - simplement pour la clarté de la lecture.
user664833

1
qu'en est-il de vérifier directement si (variable === non définie) au lieu d'utiliser typeof?
Frozen Crayon

2
@ArjunU qui provoquera une ReferenceError si la variable n'est pas déclarée. Si vous ne savez pas si une variable est déclarée ou non, utilisez la solution ci-dessus. Si vous pouvez garantir que la variable est au moins déclarée, vous pouvez utiliservariable == null
Rogue

3
C'est une meilleure solution car, comme l'a souligné @Rogue, la variable peut ne pas être déclarée.
Abdul Sadik Yalcin

Corrigez-moi si je me trompe, mais le premier conditionnel n'est-il pas un sur-ensemble du second, et donc le second conditionnel est superflu?
mars

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

14
Juste au cas où quelqu'un pense que c'est une autre demi-réponse, cela fonctionne réellement. undefinedévalue égal à null.
Chuck

3
Échec pour moi dans la console chrome ... ReferenceError: la variable n'est pas définie, donc cela pourrait fonctionner, mais pas pour moi ...
Eran Medan

48
Cela ne fonctionne que pour les variables déclarées, pas les variables qui peuvent être déclarées ou non, ce qui est rarement le cas. (Vous devez utiliser typeof + une vérification nulle pour ce cas)

11
Vous venez de comprendre que vous pouvez ajouter ce commentaire: /*jshint eqnull:true */en haut de votre document ou fonction JS, et JSHint cessera de vous avertir de vos utilisations de == null.
Web_Designer

3
@Aerovistae pouvez-vous m'indiquer une référence qui déclare explicitement qu'elle ==est cassée. La coercition if(variable == null)dans cette réponse est tout à fait logique pour moi ...
Ben Aston

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

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

  • nul

  • indéfini

  • NaN

  • chaîne vide ("")

  • 0

  • faux


13
Je pense que c'est une technique dangereuse qui s'est répandue comme un feu sauvage. Parce que beaucoup de variables qui sont vérifiées peuvent être booléennes ou numériques. Donc, si l'utilisateur ne comprend pas pleinement les conséquences, ce n'est pas bon.
utileBee

Veuillez fournir une référence de cette spécification javascript
villamejia

1
C'est la même chose que if (EmpName). Si ce undefinedsera déjà faux.
Rudy

1
Si la variable n'est pas définie. alors si (EmpName) générera une erreur
Thamaraiselvam

1
@Thamaraiselvam Je pense que Rudy aurait pu dire cela var EmpName; if (EmpName). Où la variable est définie mais sans valeur attribuée.
Hungerstar

28

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 }

1
Chrome 17.0.963.78 m donne cette erreur:ReferenceError: EmpName is not defined
Eran Medan

6
@EranMedan Je sais que c'est tard, mais j'espère que cela aidera les gens qui viendront ici plus tard. La raison pour laquelle vous obtenez une erreur est qu'elle n'a pas été déclarée du tout. Habituellement, vous auriez EmpName (ou une autre variable) être passé dans une fonction, ou la valeur de retour d'une autre fonction et donc déclaré (Exemple: "var x;"). Pour tester s'il a renvoyé une chaîne non définie, ou nulle ou vide, vous pouvez utiliser la solution ci-dessus.
Dave

Je me rends compte que c'est une question froide, mais jQuery retournera undefinedsi l'attribut n'existe pas sur l'élément (pas seulement si le sélecteur n'a pas d'éléments correspondants, comme dans la réponse). Par exemple, un imgavec non srcreviendrait undefinedpour$('img').attr('src');
codinghands

20

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.


2
J'ai rencontré un petit problème de vérification nulle. Je veux vérifier si un paramètre transmis est nul ou un objet vide { }. C'est un problème de langage courant et idiot, mais je l'avais oublié. Toutes mes recherches affichent des réponses pour une valeur nulle non définie ou des comparaisons d'égalité lâches (==), mais pas une égalité stricte (===) ou l'équivalent. Et puis ici, dans votre réponse classée -1 tout en bas de la page (avant de voter), c'est la réponse qui m'a échappé. Object.keys( obj ).length < 1ou peut-être === 0, en supposant que ce ne sera jamais -1. Quoi qu'il en soit, voté à 0, woo. : p

Merci, j'ai pu déposer cette fonction et nettoyer beaucoup de code. Pourquoi ce n'est pas une fonction JS standard me dépasse.
Andy

3
Vous devez changer tout votre ==à ===ici, alors ce serait une fonction raisonnable.
Ben McIntyre

13

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.


2
Les lecteurs doivent noter qu'une telle approche est idiomatique pour vérifier - à partir de JavaScript exécuté dans un navigateur - si une variable globale a été déclarée, et en particulier si une variable globale fournie par le navigateur (comme l'API historique) est disponible. Cela ne fonctionnera pas pour vérifier si une variable non globale est nullou undefined, et cela ne fonctionnera pas si votre JavaScript s'exécute en dehors d'un navigateur (c'est-à-dire dans Node.js). Il traitera également les globaux définis sur 0, falseou ''les mêmes que ceux qui ne sont pas déclarés ou undefinedou null, ce qui est généralement bien.
Mark Amery

Cela suppose que le script s'exécute dans un navigateur. Ce n'est pas une évidence.
GreenAsJade

13

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

3
Le cas d'utilisation ici est que je veux connaître la différence entre undefined et false. J'utiliserai alors la vérification sur null.
gast128

12

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

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

En voici la preuve:

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

Entrez la description de l'image ici

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

Entrez la description de l'image ici


9

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';
}

3
il serait préférable de définir var A = document.getElementById ("enterJob") si (A) A.className + = 'current'; de cette façon, vous travaillez à 50% pour le même résultat ... Mais peut-être que vous venez de le faire pour les spectacles et puis je salue.
Harry Svensson

8

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;

Cela n'a pas fonctionné pour moi. J'ai toujours l'erreur: ReferenceError: s is not definedpour le premier exemple.
Mark

6

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

var dvElement = $('#dvElement');

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

5

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 === ''){
}

varest un mot réservé, cela jetteraSyntaxError
dhilt

5

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.
}

4

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.
}

1
Cela exécutera le code si la variable a une valeur de false, ce qui est potentiellement indésirable.
byxor

La question est claire "Comment déterminer si la variable est" non définie "ou" nulle "?" et en javascript si une variable a une valeur nulle ou non définie, sa valeur est fausse.
M. Arnold

1
Désolé, mais c'est incorrect. Voici un JSfiddle pour le prouver.
byxor

Par votre réponse, undefined, null et quelques autres choses comme chaîne vide, +0, -0 NaNet falsepasser à travers. !l'opérateur contraint l'opérande variable- ici - à Boolean: ecma-international.org/ecma-262/#sec-toboolean
Alireza

Mais vérifiez la question: "Comment déterminer si une variable est indéfinie ou nulle", le! l'opérande utilisé avec un if reviendra toujours à true si la variable est nulle ou non définie.
M. Arnold

3

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

Cela ne répond pas à la question, qui est "comment puis-je attraper nul et non défini?" pas "comment puis-je attraper chaque valeur de falsey en JavaScript?"
temporaire_user_name

@Aerovistae, je pensais l'avoir fait avec console.log (isDeepEqual (null, null)); et console.log (isDeepEqual (non défini, non défini)); ?
Tony Tai Nguyen

2

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');
    }

Fermer mais non. Perdez le typeofet comparez à undefineddirectement, pas sous forme de chaîne. Cela fonctionne mais l'opérateur supplémentaire n'a d'autre effet que de le rendre plus verbeux.
temporaire_user_name

Dans ce cas, oui, vous avez raison, nous n'avons pas besoin d'utiliser typeof. Mais c'est une bonne pratique d'utiliser typeof lorsque vous traitez avec des variables non définies. L'une des raisons d'utiliser typeof est qu'il ne génère pas d'erreur si la variable n'a pas été déclarée.
DanKodi

C'est en fait une mauvaise chose. Vous ne voulez pas de variables non déclarées dans votre code. Vous voulez que cela lance une ReferenceError afin que vous puissiez trouver la variable et la déclarer. Vous n'essaieriez certainement pas cela dans un langage compilé comme C ++! Ce n'est pas parce que JS le permet que cela devrait être fait.
temporaire_user_name

1
Votre déclaration ou est à l'envers. Vérifier que quelque chose n'est pas défini serait la première étape, pas la seconde.
Anthony Rutledge

2

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

2

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
}

1

Meilleur moyen:

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

/* do your stuff */
}

6
Cette solution exacte a déjà été fournie par @jkindwall le 11 octobre 2013. stackoverflow.com/a/19323555/2943403 Ce message de code uniquement est complètement inutile car il n'ajoute aucune nouvelle valeur à la page. En fait, cela ajoute du ballonnement aux pages et fait perdre du temps aux chercheurs à les lire. Veuillez supprimer cette réponse.
mickmackusa

1
(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.


1
var i;

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

3
Que se passe-t-il si l'utilisateur entre le mot «non défini»?
Chuck

Votre question est bonne, elle montre que la condition est vraie, de sorte que nous devons changer l'option normale non définie en type de condition. @Chuck
KARTHIKEYAN.A

C'est faux. typeofne donnera jamais undefined, seulement la chaîne 'undefined'. De plus, i == nullc'est déjà vrai si ic'est le cas undefined, donc le second booléen serait redondant même s'il fonctionnait.
temporaire_user_name

1
Cette solution (avec les conditions inversées) a déjà été fournie par @jkindwall le 11 octobre 2013. stackoverflow.com/a/19323555/2943403 Ce message de code uniquement est complètement inutile car il n'ajoute aucune nouvelle valeur à la page. En fait, cela ajoute du ballonnement aux pages et fait perdre du temps aux chercheurs à les lire. Veuillez supprimer cette réponse.
mickmackusa

1

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) { ... }

1

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;
}

-1

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».


-1
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


-1

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
}

pouvez-vous expliquer pourquoi vous pensez que c'est le "meilleur moyen / sûr" pour effectuer les tests?
sadmicrowave

Parce que la conversion renvoie toujours une chaîne "standardisée" (c'est-à-dire [objet non défini]), vous n'avez donc pas de problème en testant les valeurs de falsification. C'est juste mon opinion basée sur des expériences que j'ai eues avec des valeurs véridiques / fausses.
n1kkou

Merci pour l'explication. Je ne critique pas, c'est une réponse intéressante, je voulais juste que vous fournissiez des explications aux autres pour expliquer pourquoi cela est potentiellement supérieur aux autres méthodes.
sadmicrowave

Pas de soucis! J'ai eu beaucoup de problèmes avec ce type de comparaisons, et jusqu'à présent, je le trouve comme l'approche la plus utile dans ce domaine.
n1kkou

-2

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

if(typeof value == 'undefined'){

Voir les commentaires dans la réponse précédente ( stackoverflow.com/a/21273362/6305294 ) concernant le typeof.
Alex

4
Ceci est une erreur. N'attrape pas null. Je ne comprends pas pourquoi de nouvelles réponses incorrectes sont fournies à une question qui a reçu une réponse correcte et complète il y a de nombreuses années. Pensez-vous que les réponses actuelles sont en quelque sorte insuffisantes?
temporaire_user_name

-4

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 .

Entrez la description de l'image ici

Voir Meilleures pratiques JavaScript .


3
C'est complètement incorrect, et une étude rapide de tout cadre ou logiciel de qualité professionnelle le confirmera en quelques instants. Utiliser ==pour comparer nullest la façon standard d'attraper nullet undefineddans JS. La coercition de type avec ==n'est pas un risque dans ce contexte spécifique, et est en fait mise à profit pour atteindre l'objectif de capture à la fois nullet undefinedsimultanément. Veuillez consacrer plus de temps à la langue avant de choisir de proposer des réponses incorrectes et trompeuses à des questions qui ont été résolues de manière satisfaisante il y a des années.
temporaire_user_name

évitez "==". Tout change toujours, je ne suis pas d'accord avec vous @Aerovistae
Albert.Qing

3
Vous n'êtes pas en désaccord avec moi - vous n'êtes pas d'accord avec l'ensemble de l'établissement JavaScript. Soyons clairs.
temporary_user_name
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.