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


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


Answers


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

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



L'opérateur typeof vérifiera si la variable est vraiment indéfinie.

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

L'opérateur typeof , contrairement aux autres opérateurs, ne typeof pas d'exception ReferenceError lorsqu'il est utilisé avec une variable non déclarée.

Cependant, notez que typeof null retournera "object" . Nous devons faire attention à éviter l'erreur d'initialiser une variable à null . Pour être sûr, voici ce que nous pourrions utiliser à la place:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Pour plus d'informations sur l'utilisation de la comparaison stricte === au lieu de la simple égalité == , voir:
Quel opérateur égal (== vs ===) devrait être utilisé dans les comparaisons JavaScript?




En JavaScript, une variable peut être définie, mais la valeur n'est pas undefined , donc la réponse la plus courante n'est pas techniquement correcte, et effectue à la place ce qui suit:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

Cela peut suffire à vos fins. Le test suivant a une sémantique plus simple, ce qui permet de décrire plus précisément le comportement de votre code et de le comprendre vous-même (si vous vous intéressez à de telles choses):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Ceci, bien sûr, suppose que vous exécutez dans un navigateur (où la window est un nom pour l'objet global). Mais si vous utilisez des globals comme ça, vous êtes probablement dans un navigateur. Subjectivement, utiliser 'name' in window est stylistiquement cohérent avec l'utilisation de window.name pour faire référence aux globals. Accéder aux globals en tant que propriétés de la window plutôt qu'en tant que variables vous permet de minimiser le nombre de variables non déclarées que vous référencez dans votre code (pour le bénéfice de linting), et évite la possibilité d'ombrage de votre variable globale. En outre, si les globaux font votre rampement de la peau, vous pourriez vous sentir plus à l'aise de les toucher seulement avec ce bâton relativement long.




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.




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 .




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 à l' 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!




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, ceci est même simple: et elle effectuerait ensemble des vérifications undefined ou null .

var values = variable ? variable : '';



undefined, boolean, string, nombre, fonction

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

}

Objet, tableau

if( foo instanceof Array ) { 

}



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.




Dans de nombreux cas, en utilisant:

if (elem) { // or !elem

fera le travail pour vous ... cela va vérifier ces cas ci-dessous:

  1. undefined : si la valeur n'est pas définie et undefined
  2. null : si c'est nul, par exemple si un élément DOM n'existe pas ...
  3. chaîne vide : ''
  4. 0 : numéro zéro
  5. NaN : pas un nombre
  6. faux

Cela couvre donc tous les cas, mais il y a toujours des cas bizarres que nous aimerions couvrir, par exemple une chaîne avec des espaces, comme ceci ' ' , cela sera défini dans javascript car il y a des espaces dans la chaîne. .. par exemple dans ce cas vous ajoutez une autre vérification en utilisant trim (), comme:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Je crée également l'image ci-dessous pour montrer rapidement la réponse:




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




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

Ou mieux

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

Fonctionne dans tous les navigateurs




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




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;

C'est souvent bien d'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;



vous pouvez utiliser l'opérateur typeof .

Par exemple,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

L'extrait de code ci-dessus renvoie la sortie comme

dataSet variable est: non défini.




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
}



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




Ma préférence est typeof(elem) != 'undefined' && elem != null .

Quoi que vous choisissiez, pensez à mettre le chèque dans une fonction comme

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Si vous ne savez pas que la variable est déclarée, continuez avec typeof (x) != 'undefined' && x != null;

Lorsque vous savez que la variable est déclarée mais peut ne pas exister, vous pouvez utiliser

existy(elem) && doSomething(elem);

La variable que vous vérifiez peut être une propriété imbriquée parfois. Vous pouvez utiliser prop || {} pour descendre la ligne en vérifiant l'existence de la propriété en question:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Après chaque propriété, utilisez (... '|| {}'). NextProp pour qu'une propriété manquante ne renvoie pas d'erreur.

Ou vous pouvez utiliser existy comme existy(o) && existy(op) && existy(opq) && doSomething(opq)




Ça dépend de la situation. Si vous recherchez quelque chose qui peut ou non avoir été défini globalement en dehors de votre code (comme jQuery peut-être), vous voulez:

if (typeof(jQuery) != "undefined")

(Pas besoin d'égalité stricte là-bas, typeof renvoie toujours une chaîne.) Mais si vous avez des arguments pour une fonction qui peut avoir été passée ou non, ils seront toujours définis, mais null s'ils sont omis.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"



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



J'utilise deux manières différentes en fonction de l'objet.

if( !variable ){
  // variable is either
  // 1. empty string i.e. '';
  // 2. Integer 0;
  // 3. undefined;
  // 4. null;
}

Parfois, je ne veux pas évaluer une chaîne vide comme falsey, alors j'utilise ce cas

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Si vous avez besoin du contraire, alors dans la première instance! Variable devient !! variable, et dans la fonction invalide === devenez! = Et les noms de fonctions deviennent non valides.




Un peu plus fonctionnel et facile à utiliser:

function exist(obj)
{
    return (typeof obj !== 'undefined');
}

La fonction retournera true si elle existe, sinon false si elle n'existe pas.




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
}



Qu'en est-il un simple:

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



Pour vérifier si une variable a été déclarée / définie, j'ai fait cette astuce.

Je n'ai pas trouvé un moyen d'extraire le code à une fonction, même avec eval .

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}



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.




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.