Comment vérifier une variable non définie en JavaScript

914

Je voulais vérifier si la variable est définie ou non. Par exemple, ce qui suit génère une erreur non définie

alert( x );

Comment puis-je intercepter cette erreur?

Jineesh
la source
5
On dirait que c'est un grand-père: stackoverflow.com/questions/1485840/… stackoverflow.com/questions/2647867/… - grands gramps peut-être ceci: stackoverflow.com/questions/27509/…
aléatoire
1
Ce n'est pas un doublon du doublon marqué. La résolution variable et la résolution des propriétés des objets sont des choses très différentes. Un meilleur doublon est de savoir comment vérifier si une variable existe en javascript? .
RobG
Votre erreur est due au fait que la variable n'est pas déclarée. La plupart des réponses sont axées sur l'affectation. Voir ma réponse pour en savoir plus. De plus, beaucoup d'entre eux déclarent à tort que null et indéfini sont des objets en JavaScript. Ce sont des primitifs , pas des objets ...
JBallin

Réponses:

1691

En JavaScript, nullc'est un objet. Il y a une autre valeur pour les choses qui n'existent pas undefined. Le DOM renvoie nullpour presque tous les cas où il ne parvient pas à trouver une certaine structure dans le document, mais en JavaScript lui undefined- même est la valeur utilisée.

Deuxièmement, non, il n'y a pas d'équivalent direct. Si vous voulez vraiment vérifier spécifiquement null, faites:

if (yourvar === null) // Does not execute if yourvar is `undefined`

Si vous voulez vérifier si une variable existe, cela ne peut être fait qu'avec try/ catch, car typeoftraitera une variable non déclarée et une variable déclarée avec la valeur de undefinedcomme équivalente.

Mais, pour vérifier si une variable est déclarée et n'est pas undefined:

if (yourvar !== undefined) // Any scope

Auparavant, il était nécessaire d'utiliser l' typeofopérateur pour rechercher les indéfinis en toute sécurité, car il était possible de réaffecter undefinedtout comme une variable. L'ancienne façon ressemblait à ceci:

if (typeof yourvar !== 'undefined') // Any scope

Le problème de la undefinedréaffectation a été résolu dans ECMAScript 5, qui a été publié en 2009. Vous pouvez désormais utiliser ===et !==tester en toute sécurité undefinedsans utiliser typeofcar il undefinedest en lecture seule depuis un certain temps.

Si vous voulez savoir si un membre existe indépendamment mais ne vous souciez pas de sa valeur:

if ('membername' in object) // With inheritance
if (object.hasOwnProperty('membername')) // Without inheritance

Si vous voulez savoir si une variable est véridique :

if (yourvar)

La source

Natrium
la source
71
undefined n'est pas un mot réservé; vous (ou le code de quelqu'un d'autre) pouvez faire "undefined = 3" et cela cassera deux de vos tests.
Jason S
6
"Si vous savez que la variable existe mais que vous ne savez pas si elle contient une valeur" - hein?!
Jason S
36
Je pense qu'il fait référence à une variable déclarée qui n'a pas été affectée à. par exemple: var foo; // foo existe mais n'a pas de valeur
Wally Lawless
3
Hmmm ... Je viens de remarquer le lien "source": tout ce post est une citation directe d'une liste de diffusion, et devrait probablement être édité pour que ce soit plus clair, car l'auteur original n'est pas disponible pour clarifier.
Jason S
11
"En JavaScript, null est un objet.", Ce n'est pas vrai, et probablement, le coupable de cette idée fausse est l' typeofopérateur ( typeof null == 'object'). La nullvaleur est une valeur primitive , qui est la seule valeur du type Null .
CMS
347

La seule façon de vraiment tester si une variable undefinedest de faire ce qui suit. Rappelez-vous, undefined est un objet en JavaScript.

if (typeof someVar === 'undefined') {
  // Your variable is undefined
}

Certaines des autres solutions de ce fil vous feront croire qu'une variable n'est pas définie même si elle a été définie (avec une valeur NULL ou 0, par exemple).

Michael Wales
la source
18
Parce que la question n'était PAS NON DÉFINIE ici devrait être typeof someVar! == 'indéfini', non?
eomeroff
1
Vraiment, je ne pense pas que indéfini soit un objet, consultez d'abord la documentation developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures
Nicramus
2
Le seul test qui ne produit pas de ReferenceError.
Nostalg.io
2
Ce code est correct, mais je pense que dire undefinedest un objet en javascript est une désinformation. Est-ce que cette déclaration se rapporte à votre réponse de toute façon? Il s'agit d'une valeur undefinedde type undefined, affectée à l'identificateur global nommé undefined.
SimplGy
1
C'est maintenant incorrect en ce que c'est le seul moyen. undefinedest en lecture seule depuis ES5. Vous pouvez tester sans risque pour non défini en utilisant if (x === undefined) {...}comme ou en utilisant un raccourci ceci: if (x === void 0).
Stephen M Irving
66

Techniquement, la bonne solution est (je crois):

typeof x === "undefined"

Vous pouvez parfois devenir paresseux et utiliser

x == null

mais cela permet à la fois à une variable non définie x et à une variable x contenant null de renvoyer true.

Jason S
la source
1
si vous tapez var x;et typeof x;vous obtiendrez "undefined"comme si vous l'aviez faittypeof lakjdflkdsjflsj;
Muhammad Umer
Il n'y a donc aucun moyen de vérifier la variable non définie mais déclarée?
Muhammad Umer
1
Je ne le pense pas; Je ne sais pas pourquoi vous voudriez.
Jason S
ujndefined ne devrait pas être entre les
apex
qu'entendez-vous par apices?
Jason S
19

Une version encore plus simple et plus abrégée serait:

if (!x) {
   //Undefined
}

OU

if (typeof x !== "undefined") {
    //Do something since x is defined.
}
Dmitri Farkov
la source
26
le premier élément de code peut être incorrect si x est défini à partir d'un appel de fonction. comme x = A (); si A ne retourne rien, il retournera "non défini" par défaut. Faire un! X serait vrai, ce qui serait logiquement correct. Cependant, si A () renvoie 0, alors! X doit être faux car x = 0. Cependant, dans JS,! 0 est également vrai.
Rajat
le deuxième code peut être raccourci en: if (! typeof (XX)) {...} else {...}
Alejandro Silva
2
@AlejandroSilva Désolé pour une réponse tardive. Cela ne fonctionnera pas puisque typeof renvoie une chaîne, donc il retournera 'undefined' pour une variable non définie, qui à son tour sera évaluée comme TRUE conduisant ainsi à un faux positif d'une var définie.
Dmitri Farkov
5
Veuillez vous débarrasser du premier extrait, c'est juste mauvais
Juan Mendes
1
D'autres commentaires ont souligné que le premier exemple est mauvais, mais pas clairement pourquoi. Donc, pour tout nouveau codeur:! X ne teste pas si x est défini, mais s'il est vrai. Les chaînes, les valeurs booléennes vraies et positives sont toutes véridiques (et j'oublie peut-être certaines choses), mais d'autres valeurs potentiellement valides comme 0, booléennes fausses et une chaîne vide ne sont pas véridiques. Le premier exemple peut fonctionner pour des cas d'utilisation spécifiques (par exemple, tester une chaîne si vous pouvez traiter vide de la même manière qu'indéfini), mais en raison des nombreux cas où il ne le sera pas, il ne devrait pas être considéré comme la méthode par défaut pour vérifier.
cfc
16

J'ai souvent fait:

function doSomething(variable)
{
    var undef;

    if(variable === undef)
    {
         alert('Hey moron, define this bad boy.');
    }
}
Joe
la source
9
Pensez à remplacer "==" par "===". Si vous appelez doSomething (null), vous recevrez également l'alerte. Sauf si c'est ce que vous voulez.
Jason S
Oui. Vous devez décider si vous voulez l'équivalent ou exactement égal. Les deux cas pourraient avoir une utilité.
Joe
1
vérifier simplement comme ceci-> if (typeof variableName! == 'undefined') {alert (variableName);}
Muhammad Sadiq
cela est inutile car vous ne pourrez de toute façon pas passer une var non définie à une fonction
avalanche1
2
Sûr que vous pouvez. Essayez d'appeler une fonction sans argument.
Joe
3

Vous pouvez également utiliser l'opérateur conditionnel ternaire:

var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);

//var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);

John
la source
Et si var a = false;? Vous devriez vérifier que si à la a===undefinedplace
Iter Ator
1
Question: vérifier une variable non définie ..... Ceci est une variable indéfinie: var x; faire ci-dessus générera une erreur
Muhammad Umer
"Si a = false, alors il affichera" je ne sais pas 'a' "" - C'est le problème, la question est de tester si elle est définie, pas si c'est vrai. Si a est défini comme faux, alors a n'est pas indéfini. Cela renvoie le mauvais résultat dans ce cas. Voir mon commentaire sur stackoverflow.com/a/858270/2055492 pour plus de détails sur les raisons pour lesquelles cette approche ne fonctionne pas.
cfc
non seulement !atestera vrai pour undefined, il testera également vrai pour 0et nullet false. Ceci est très incorrect et devrait être supprimé.
Stephen M Irving
2

J'utilise souvent le moyen le plus simple:

var variable;
if (variable === undefined){
    console.log('Variable is undefined');
} else {
    console.log('Variable is defined');
}

ÉDITER:

Sans initialiser la variable, une exception sera levée "Uncaught ReferenceError: la variable n'est pas définie ..."

mokiSRB
la source
2
Uncaught ReferenceError: variable is not defined
Muhammad Umer
@MuhammadUmer, faux! variableest défini par var variable;. Et cet extrait remplacera variablela portée locale. Il peut briser la logique qui s'attend à accéder à une fermeture ou à une variable globale. C'est à dire:var variable = 1; function test() { var variable; if (variable === undefined){ console.log('Variable is undefined'); } else { console.log('Variable is defined: ' + variable); } } test(); // Variable is undefined
Евгений Савичев
2

Une autre "solution" potentielle consiste à utiliser l' windowobjet. Il évite le problème d'erreur de référence dans un navigateur.

if (window.x) {
    alert('x exists and is truthy');
} else {
    alert('x does not exist, or exists and is falsy');
}
ubershmekel
la source
Cela ne résout pas du tout la question d'origine et est totalement hors de propos. L'affiche ne demandait pas comment tester si quelque chose est vrai ou faux, il a demandé comment tester undefined. Cela ne fera pas ça.
Stephen M Irving
2

L'erreur vous dit que cela xn'existe même pas! Il n'a pas été déclaré , ce qui est différent de l' attribution d' une valeur.

var x; // declaration
x = 2; // assignment

Si vous déclariez x, vous n'obtiendrez pas d'erreur. Vous obtiendrez une alerte qui indique undefinedcar xexiste / a été déclaré mais n'a pas reçu de valeur.

Pour vérifier si la variable a été déclarée, vous pouvez utiliser typeofn'importe quelle autre méthode pour vérifier si une variable existe provoquera la même erreur que vous avez initialement.

if(typeof x  !==  "undefined") {
    alert(x);
}

Ceci vérifie le type de la valeur stockée dans x. Il ne reviendra que undefineds'il xn'a pas été déclaré OU s'il a été déclaré et n'a pas encore été attribué.

JBallin
la source
undefined est en lecture seule depuis ES5 (version 2009) et vous n'avez plus besoin de l' typeofopérateur.
Stephen M Irving
2

L' voidopérateur renvoie undefinedpour tout argument / expression qui lui est passé. de sorte que vous pouvez tester contre le résultat ( en fait quelques minifiers changer votre code de undefinedpour void 0sauver un couple de personnages)

Par exemple:

void 0
// undefined

if (variable === void 0) {
    // variable is undefined
}
svarog
la source
Ding Ding! Ceci est la bonne réponse. Dommage que ce soit tout en bas. Tout le monde est tellement accro à continuer à utiliser typeofet la réflexion undefinedpeut être réaffectée, ce qui n'a pas été possible depuis environ une décennie.
Stephen M Irving
C'était également sûr avant ES5 car à l'époque même si vous aviez réaffecté undefined, car Dieu ne sait que pour quelle raison, l'utilisation void 0reviendra toujours undefinedmalgré tout.
Stephen M Irving
1

Nous pouvons vérifier undefinedcomme suit

var x; 

if (x === undefined) {
    alert("x is undefined");
} else {
     alert("x is defined");
}
Arshid KV
la source
1

Faites juste quelque chose comme ci-dessous:

function isNotDefined(value) {
  return typeof value === "undefined";
}

et appelez-le comme:

isNotDefined(undefined); //return true
isNotDefined('Alireza'); //return false
Alireza
la source
0

La réponse acceptée est correcte. Je voulais juste ajouter une option de plus. Vous pouvez également utiliser le try ... catchbloc pour gérer cette situation. Un exemple bizarre:

var a;
try {
    a = b + 1;  // throws ReferenceError if b is not defined
} 
catch (e) {
    a = 1;      // apply some default behavior in case of error
}
finally {
    a = a || 0; // normalize the result in any case
}

Soyez conscient du catchbloc, qui est un peu désordonné, car il crée une portée au niveau du bloc. Et, bien sûr, l'exemple est extrêmement simplifié pour répondre à la question posée, il ne couvre pas les meilleures pratiques de traitement des erreurs;).

Евгений Савичев
la source
0

J'utilise une petite fonction pour vérifier qu'une variable a été déclarée, ce qui réduit vraiment l'encombrement dans mes fichiers javascript. J'ajoute une vérification de la valeur pour m'assurer que la variable existe non seulement, mais a également reçu une valeur. La deuxième condition vérifie si la variable a également été instanciée, car si la variable a été définie mais pas instanciée (voir l'exemple ci-dessous), elle générera toujours une erreur si vous essayez de référencer sa valeur dans votre code.

Non instancié - var my_variable;Instancié -var my_variable = "";

function varExists(el) { 
  if ( typeof el !== "undefined" && typeof el.val() !== "undefined" ) { 
    return true; 
  } else { 
    return false; 
  } 
}

Vous pouvez ensuite utiliser une instruction conditionnelle pour tester que la variable a été à la fois définie ET instanciée comme ceci ...

if ( varExists(variable_name) ) { // checks that it DOES exist } 

ou pour tester qu'il n'a pas été défini et instancié

if( !varExists(variable_name) ) { // checks that it DOESN'T exist }
MistyDawn
la source
1
Pourquoi ne pas retourner votre prédicat immédiatement? return typeof el !== "undefined" && typeof el.val() !== "undefined"
skubski