vide - JavaScript vérifie si la variable existe(est définie/initialisée)




verifier si une variable existe javascript (19)

Vérifier si un objet hasOwnProperty()

Une alternative à la pléthore de réponses typeof , est l'utilisation de hasOwnProperty() qui vérifie bien sûr si un objet (à peu près tout dans JS) a une propriété, c'est -à- dire une variable (entre autres choses).

La méthode hasOwnProperty() renvoie un booléen indiquant si l'objet possède la propriété spécifiée en tant que propriété propre (non héritée).

Chaque objet descendant d' Object hérite de la méthode hasOwnProperty() . Cette méthode peut être utilisée pour déterminer si un objet a la propriété spécifiée en tant que propriété directe de cet objet; Contrairement in opérateur in , cette méthode ne vérifie pas la chaîne prototype de l'objet.

// Globally established (therefore) properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
// window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ),             // true
    window.hasOwnProperty( "bar" ),             // true
    window.hasOwnProperty( "baz" ),             // true
    window.hasOwnProperty( "qux" ),             // false
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

Ce qui est génial à propos de hasOwnProperty() est qu'en l'appelant, nous n'utilisons pas une variable qui pourrait encore être indéfinie - ce qui bien sûr est la moitié du problème en premier lieu.

Bien que ce ne soit pas toujours la solution parfaite ou idéale , dans certaines circonstances, c'est juste le travail!

Quelle méthode de vérification si une variable a été initialisée est meilleure / correcte? (En supposant que la variable pourrait contenir n'importe quoi (chaîne, int, objet, fonction, etc.))

if (elem) { // or !elem

ou

if (typeof(elem) !== 'undefined') {

ou

if (elem != null) {

Comment vérifier si une variable existe

C'est une solution à toute épreuve pour tester si une variable existe et a été initialisée:

var setOrNot = typeof variable !== typeof undefined;

Il est le plus souvent utilisé en combinaison avec un opérateur ternaire pour définir une valeur par défaut dans le cas où une certaine variable n'a pas été initialisée:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Problèmes d'encapsulation

Malheureusement, vous ne pouvez pas simplement encapsuler votre chèque dans une fonction.

Vous pourriez penser à faire quelque chose comme ceci:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Cependant, cela produira une erreur de référence si vous appelez par exemple. isset(foo) et la variable foo n'a pas été définie, car vous ne pouvez pas transmettre une variable isset(foo) à une fonction:

ReferenceError non intercepté: foo n'est pas défini

Tester si les paramètres de la fonction sont indéfinis

Bien que notre fonction isset ne puisse pas être utilisée pour tester si une variable existe ou non (pour les raisons expliquées ci-dessus), elle nous permet de tester si les paramètres d'une fonction sont indéfinis:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Même si aucune valeur pour y n'est transmise au test fonction, notre fonction isset fonctionne parfaitement dans ce contexte, car y est connu dans le test fonction comme une valeur undefined .


Cela dépend si vous vous souciez seulement que la variable a été définie ou si vous voulez qu'elle ait une valeur significative.

Vérifier si le type n'est pas défini vérifiera si la variable a encore été définie.

=== null ou !== null ne vérifie que si la valeur de la variable est exactement null .

== null ou != null vérifiera si la valeur est undefined ou null .

if(value) vérifiera si la variable est undefined , null , 0 ou une chaîne vide.


Ces réponses (à part la solution de Fred Gandt) sont toutes incorrectes ou incomplètes.

Supposons que j'ai besoin de mon variableName; pour porter une valeur undefined , et par conséquent il a été déclaré d'une manière telle que var variableName; ce qui signifie qu'il est déjà initialisé ; - Comment vérifier si c'est déjà déclaré?

Ou encore mieux - comment vérifier immédiatement si "Book1.chapter22.paragraph37" existe avec un seul appel, mais pas une erreur de référence?

Nous le faisons en utilisant l'opérateur JasvaScript le plus puissant, l'opérateur in .:

"[variable||property]" in [context||root] 
>> true||false

En période de popularité de pointe AJAX, j'ai écrit une méthode (appelée plus tard) isNS () qui est capable de déterminer si l'espace de noms existe, y compris des tests approfondis pour les noms de propriété tels que "Book1.chapter22.paragraph37" et beaucoup plus.

Mais comme il a déjà été publié et en raison de sa grande importance, il mérite d'être publié dans un fil séparé je ne le publierai pas ici mais je fournirai des mots-clés ( javascript + isNS ) qui vous aideront à localiser le code source. explications nécessaires.


Dans la majorité des cas, vous utiliseriez:

elem != null

Contrairement à un simple if (elem) , il autorise 0 , false , NaN et '' , mais rejette null ou undefined , ce qui en fait un bon test général pour la présence d'un argument, ou la propriété d'un objet.

Les autres contrôles ne sont pas non plus incorrects, ils ont juste des usages différents:

  • if (elem) : peut être utilisé si elem est garanti être un objet, ou si false , 0 , etc. sont considérés comme des valeurs "par défaut" (donc équivalent à undefined ou null ).

  • typeof elem == 'undefined' peut être utilisé dans les cas où une valeur null spécifiée a une signification distincte pour une variable ou une propriété non initialisée.

    • C'est la seule vérification qui ne jette pas d'erreur si elem n'est pas déclaré (c'est-à-dire aucune instruction var , pas une propriété de window , ou un argument de fonction). Ceci est, à mon avis, plutôt dangereux car il permet de passer inaperçu. Pour éviter cela, voir la méthode ci-dessous.

Aussi utile est une comparaison stricte contre undefined :

if (elem === undefined) ...

Toutefois, étant donné que le undefined global undefined peut être remplacé par une autre valeur, il est préférable de déclarer la variable undefined dans la portée actuelle avant de l'utiliser:

var undefined; // really undefined
if (elem === undefined) ...

Ou:

(function (undefined) {
    if (elem === undefined) ...
})();

Un avantage secondaire de cette méthode est que les minisers JS peuvent réduire la variable undefined à un seul caractère, en vous épargnant quelques octets à chaque fois.


Dans la situation particulière décrite dans la question,

typeof window.console === "undefined"

est identique à

window.console === undefined

Je préfère ce dernier car il est plus court.

S'il vous plaît noter que nous recherchons la console uniquement dans la portée globale (qui est un objet window dans tous les navigateurs). Dans cette situation particulière, c'est souhaitable. Nous ne voulons pas de console définie ailleurs.

@BrianKelley dans sa grande réponse explique les détails techniques. J'ai seulement ajouté une conclusion manquant et digéré en quelque chose de plus facile à lire.


Il est difficile de distinguer entre indéfini et nul. Null est une valeur que vous pouvez affecter à une variable lorsque vous voulez indiquer que la variable n'a pas de valeur particulière. Undefined est une valeur spéciale qui sera la valeur par défaut des variables non affectées.


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);


Il existe une autre méthode à court terme pour vérifier cela, lorsque vous effectuez des affectations simples et des vérifications connexes. Utilisez simplement l' opérateur conditionnel (ternaire).

var values = typeof variable !== 'undefined' ? variable : '';

Cela sera également utile lorsque vous essaierez de déclarer la variable globale avec l'attribution d'instance de la variable de référence.

Si vous voulez vérifier la variable ne doit pas être undefined ou null . Puis effectuez ci-dessous vérifier.

Lorsque la variable est déclarée, et si vous voulez vérifier la valeur, c'est même Simple: et elle effectue null vérifications undefined et null ensemble.

var values = variable ? variable : '';

Je ne peux pas voir cela dans les réponses ci-dessus, donc je vais le suggérer ici, je suppose.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x retournera vrai si x est soit nul, soit indéfini , donc !! x ne retournera vrai que si x n'est ni indéfini ni nul.

Je me rends compte que cela représente également le cas null, mais voici un avertissement juste à ce sujet.


Je ne savais pas si cela aiderait, je devais vérifier si un Var qui était défini sur la page était en train d'être ramassé avant d'exécuter les scripts liés et que ce qui suit fonctionnait bien pour moi.

if (window.myvar) { // run scripts here }

C'est un peu simple mais bien pour les offs ou les goûts.


La réponse la plus élevée est correcte, utilisez typeof.

Cependant, ce que je voulais souligner, c'est qu'en JavaScript, undefined est mutable (pour une raison impie). Donc, faire simplement une vérification de varName !== undefined a le potentiel de ne pas toujours retourner comme vous le souhaitez, car d'autres libs pourraient avoir changé undefined. Quelques réponses (@ skalee, par exemple), semblent préférer ne pas utiliser typeof , et cela pourrait causer des ennuis.

La "vieille" façon de gérer cela était de déclarer indéfinie comme une var pour compenser tout muting / over-riding potentiel de undefined . Cependant, le meilleur moyen est toujours d'utiliser typeof car il ignorera toute substitution d' undefined partir d'un autre code. Surtout si vous écrivez du code pour une utilisation dans la nature, où qui sait quoi d'autre pourrait être en cours d'exécution sur la page ...


Le contrôle le plus robuste 'est-il défini' est avec typeof

if (typeof elem === 'undefined')

Si vous recherchez simplement une variable définie pour affecter une valeur par défaut, pour une liner facilement lisible, vous pouvez souvent le faire:

elem = elem || defaultElem;

Il est souvent bon à utiliser, voir: Idiomatique façon de définir la valeur par défaut en javascript

Il y a aussi cette ligne utilisant le mot-clé typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

Null est une valeur dans JavaScript et typeof null renvoie "object"

Par conséquent, la réponse acceptée ne fonctionnera pas si vous transmettez des valeurs nulles. Si vous passez des valeurs nulles, vous devez ajouter une vérification supplémentaire pour les valeurs nulles:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

Pour contribuer au débat, si je sais que la variable doit être une chaîne ou un objet, je préfère toujours if (!variable) , donc je vérifie si elle est fausse. Cela peut amener à plus de code propre afin que, par exemple:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

..peut être réduit à:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 


Qu'en est-il un simple:

if(!!variable){
  //the variable is defined
}

Si vous voulez que le bloc défini fasse quelque chose, utilisez ce

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Si vous voulez que le bloc indéfini fasse quelque chose ou assigne ou définisse la variable, utilisez ceci

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

Vous voulez l'opérateur typeof . Plus précisément:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

undefined, boolean, string, nombre, fonction

if( typeof foo !== 'undefined' ) { 

}

Objet, tableau

if( foo instanceof Array ) { 

}

if (typeof console != "undefined") {    
   ...
}

Ou mieux

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Fonctionne dans tous les navigateurs





undefined