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 génère une erreur non définie

alert( x );

Comment puis-je intercepter cette erreur?

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

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

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.

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

J'ai souvent fait:

function doSomething(variable)
{
    var undef;

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

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

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

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

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

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
}

Nous pouvons vérifier undefinedcomme suit

var x; 

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

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

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

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 }