web-dev-qa-db-fra.com

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

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

alert( x );

Comment puis-je attraper cette erreur?

javascriptvariablesundefined
805
Jineesh

En JavaScript, null est un objet. Il existe une autre valeur pour les choses qui n'existent pas, undefined. Le DOM retourne null dans presque tous les cas où il n'a pas trouvé de structure dans le document, mais dans JavaScript lui-même, undefined est la valeur utilisée.

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

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

Si vous voulez vérifier si une variable existe, vous ne pouvez le faire qu'avec trycatch, puisque typeof traitera une variable non déclarée et une variable déclarée avec la valeur undefined comme équivalente.

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

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

Si vous connaissez la variable et que vous souhaitez vérifier si une valeur est stockée dans celle-ci:

if (yourvar !== undefined)

Si vous voulez savoir si un membre existe de manière indépendante 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érité :

if (yourvar)

La source

1564
Natrium

La seule façon de vérifier si une variable est undefined est de procéder comme suit. Rappelez-vous, indéfini est un objet en JavaScript.

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

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

313
Michael Wales

Techniquement, la solution appropriée 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 retourner vrai.

61
Jason S

J'ai souvent fait:

function doSomething(variable)
{
    var undef;

    if(variable === undef)
    {
         alert('Hey moron, define this bad boy.');
    }
}
14
Joe

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

if (!x) {
   //Undefined
}

OR

if (typeof x !== "undefined") {
    //Do something since x is defined.
}
14
Dmitri Farkov

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

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

3
John

Une autre "solution" potentielle consiste à utiliser l'objet window. Cela é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');
}
3
ubershmekel

J'utilise souvent le moyen le plus simple:

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

MODIFIER:

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

1
mokiSRB

L'opérateur void renvoie undefined pour tout argument/expression qui lui est transmis. afin que vous puissiez tester le résultat (en fait, certains minificateurs changent votre code de undefined à void 0 pour enregistrer quelques caractères)

Par exemple:

void 0
// undefined

if (variable === void 0) {
    // variable is undefined
}
0
svarog

Nous pouvons vérifier undefined comme suit 

var x; 

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

L’erreur vous dit que x n’existe même pas! Ce n’est pas déclaré, ce qui est différent d’être affecté une valeur.

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

Si vous déclariez x, vous n’obtiendrez pas d’erreur. Vous obtiendrez une alerte indiquant undefined car x existe/a été déclaré mais aucune valeur n’a été affectée.

Pour vérifier si la variable a été déclarée, vous pouvez utiliser typeof. Toute autre méthode permettant de vérifier l'existence d'une variable provoquera la même erreur que celle que vous aviez initialement.

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

Ceci vérifie le type de la valeur stockée dans x. Il ne retournera undefined que lorsque x n’a pas été déclaré OR s’il a été déclaré et n’a pas encore été attribué.

0
JBallin

J'utilise une petite fonction pour vérifier qu'une variable a été déclarée, ce qui réduit considérablement l'encombrement de mes fichiers javascript. J'ajoute une vérification de la valeur pour m'assurer que la variable existe non seulement, mais qu'une valeur lui a également été affectée. 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 exemple ci-dessous), une erreur sera toujours générée 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 vérifier que la variable a été définie ET instanciée comme ceci ...

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

ou pour vérifier qu'il n'a pas encore été défini et instancié ...

if( !varExists(variable_name) ) { // checks that it DOESN'T exist }
0
MistyDawn

Faites juste quelque chose comme ci-dessous:

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

et appelez comme ça:

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

La réponse acceptée est correcte. Je voulais juste ajouter une option supplémentaire. Vous pouvez également utiliser le bloc try ... catch 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
}

Tenez compte du bloc catch, qui est un peu compliqué, 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;).

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