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

if (elem) { // or !elem

ou

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

ou

if (elem != null) {

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

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

L' typeofopérateur vérifiera si la variable n'est pas vraiment définie.

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

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

Cependant, notez que typeof nullcela reviendra "object". Nous devons être prudents pour é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 l'égalité simple ==, voir:
Quel opérateur égal (== vs ===) doit être utilisé dans les comparaisons JavaScript?

Dans de nombreux cas, en utilisant:

if (elem) { // or !elem

fera le travail pour vous! ... ceci vérifiera les cas ci-dessous:

1. non défini : si la valeur n'est pas définie et qu'il estundefined
2. null : s'il 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

Donc, cela couvrira tous les cas, mais il y a toujours des cas étranges que nous aimerions couvrir également, par exemple, une chaîne avec des espaces, comme celle- ' 'ci, cela sera défini en javascript car il y a des espaces à l'intérieur de la chaîne ... par exemple, dans ce cas, vous ajoutez une vérification supplémentaire en utilisant trim (), comme:

if(elem) {

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

En outre, ces vérifications concernent uniquement les valeurs , car les objets et les tableaux fonctionnent différemment en Javascript, les tableaux []et objets vides {}sont toujours vrais .

Je crée l'image ci-dessous pour montrer un bref résumé de la réponse:

En JavaScript, une variable peut être définie, mais conservez la valeur 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 facilite la description précise du comportement de votre code et sa compréhension vous-même (si vous vous souciez de telles choses):

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

Bien entendu, cela suppose que vous exécutez dans un navigateur (où windowest le nom de l'objet global). Mais si vous fouinez avec des mondiaux comme celui-ci, vous êtes probablement dans un navigateur. Subjectivement, l'utilisation 'name' in windowest stylistiquement cohérente avec l'utilisation window.namepour faire référence aux globaux. L'accès aux globaux en tant que propriétés windowplutô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 (au profit du linting), et évite la possibilité que votre global soit masqué par une variable locale. De plus, si les globaux font ramper votre peau, vous pourriez vous sentir plus à l'aise de les toucher uniquement avec ce bâton relativement long.

Dans la majorité des cas, vous utiliseriez:

elem != null

Contrairement à simple if (elem), il permet 0, false, NaNet '', mais rejette nullou 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 vérifications ne sont pas incorrectes non plus, elles ont juste des usages différents:

• if (elem): Peut être utilisé si elemest garanti d'être un objet, ou si false, 0etc. sont considérés comme des valeurs « par défaut » (donc équivalent à undefinedou null).

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

  • C'est la seule vérification qui ne générera pas d'erreur si elle elemn'est pas déclarée (c'est-à-dire sans varinstruction, pas une propriété de window, ou pas un argument de fonction). C'est, à mon avis, plutôt dangereux car cela permet aux fautes de frappe de passer inaperçues. Pour éviter cela, consultez la méthode ci-dessous.

Une comparaison stricte avec undefined:

if (elem === undefined) ...

Cependant, parce que le undefined peut être remplacé par une autre valeur, il est préférable de déclarer la variable undefineddans 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 minificateurs JS peuvent réduire la undefinedvariable à un seul caractère, ce qui vous fait économiser quelques octets à chaque fois.

Vérifiez si window. hasOwnProperty( " varname" )

Une alternative à la pléthore de typeof réponses;

Variables globales déclarées avec une var varname = value;instruction dans la portée globale

est accessible en tant que propriétés de l'objet fenêtre.

En tant que telle, la hasOwnProperty()méthode, qui

renvoie un booléen indiquant si l'objet a la propriété spécifiée comme sa propre propriété (par opposition à l'hériter)

peut être utilisé pour déterminer si

a varde "varname" a été déclaré globalement, c'est -à- dire qu'il est une propriété de window.

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

Ce qui est génial, hasOwnProperty()c'est qu'en l'appelant, nous n'utilisons pas une variable qui pourrait encore être non déclarée - 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!

Remarques

Ce qui précède est vrai lors de l'utilisation varpour définir une variable , par opposition à letlaquelle:

déclare une variable locale de portée de bloc, l'initialisant éventuellement à une valeur.

est différent du var mot clé, qui définit une variable globalement ou localement à une fonction entière quelle que soit la portée du bloc.

Au niveau supérieur des programmes et des fonctions, letcontrairement à var, ne crée pas de propriété sur l'objet global.

Pour être complet: les const constantes ne sont, par définition, pas réellement variables (bien que leur contenu puisse l'être); de manière plus pertinente:

Les constantes globales ne deviennent pas des propriétés de l'objet fenêtre, contrairement aux varvariables. Un initialiseur pour une constante est requis; c'est-à-dire que vous devez spécifier sa valeur dans la même instruction dans laquelle il est déclaré.

La valeur d'une constante ne peut pas changer lors de la réaffectation et elle ne peut pas être redéclarée.

La déclaration const crée une référence en lecture seule à une valeur. Cela ne signifie pas que la valeur qu'il contient est immuable, mais simplement que l'identificateur de variable ne peut pas être réaffecté.

Étant donné que les letvariables ou les constconstantes ne sont jamais les propriétés d'un objet qui a hérité de la hasOwnProperty()méthode, il ne peut pas être utilisé pour vérifier leur existence.

Concernant la disponibilité et l'utilisation de hasOwnProperty():

Chaque objet issu d' Object hérite de la hasOwnProperty()méthode. [...] contrairement à l' inopérateur, cette méthode ne vérifie pas la chaîne prototype de l'objet.

Comment vérifier si une variable existe

Ceci est une solution assez à l'épreuve des balles 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 ça:

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 foon'a pas été définie, car vous ne pouvez pas transmettre une variable non existante à une fonction:

Uncaught ReferenceError: foo n'est pas défini

Tester si les paramètres de fonction ne sont pas définis

Bien que notre issetfonction 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 ne sont pas dé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 yn'est transmise à la fonction test, notre issetfonction fonctionne parfaitement dans ce contexte, car elle yest connue dans la fonction testcomme une undefinedvaleur.

Il existe un autre moyen rapide de vérifier cela lorsque vous effectuez des affectations simples et des vérifications associées. Utilisez simplement l' opérateur conditionnel (ternaire).

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

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

Si vous vouliez vérifier la variable ne devrait pas être undefinedou null. Effectuez ensuite la vérification ci-dessous.

Lorsque la variable est déclarée, et si vous voulez vérifier la valeur, c'est même simple: et elle fonctionnerait undefinedet nullvérifierait ensemble.

var values = variable ? variable : '';

Un moyen court de tester une variable non déclarée (non indéfinie) est

if (typeof variable === "undefined") {
  ...
}

Je l'ai trouvé utile pour détecter un script exécuté en dehors d'un navigateur (n'ayant pas déclaré de windowvariable).

Cela dépend si vous vous souciez juste 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 déjà été définie.

=== nullou !== nullvérifiera seulement si la valeur de la variable est exactementnull .

== nullou != nullvérifiera si la valeur est undefinedou null.

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

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

Cependant, ce que je voulais souligner, c'est que dans JavaScript undefinedest mutable (pour une raison impie). Donc, simplement faire une vérification pour varName !== undefineda le potentiel de ne pas toujours revenir comme vous vous y attendez, car d'autres bibliothèques pourraient avoir changé non définies. Quelques réponses (@ skalee, pour une) semblent préférer ne pas utiliser typeof, et cela pourrait avoir des ennuis.

La "vieille" façon de gérer cela était de déclarer undefined comme var pour compenser tout muting / dépassement potentiel de undefined. Cependant, le meilleur moyen est toujours d'utiliser typeofcar il ignorera tout remplacement d'un undefinedautre code. Surtout si vous écrivez du code à utiliser dans la nature où qui sait quoi d'autre pourrait être exécuté 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

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), alors vérifiez si sa fausse. Cela peut apporter un code plus 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); 
}

.. pourrait être réduit à:

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

Il est difficile de distinguer entre non défini et nul. Null est une valeur que vous pouvez affecter à une variable lorsque vous souhaitez 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);

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

Par conséquent, la réponse acceptée ne fonctionnera pas si vous passez des valeurs nulles. Si vous transmettez 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
}

La vérification la plus robuste «est-elle définie» est avec typeof

if (typeof elem === 'undefined')

Si vous recherchez simplement une variable définie pour attribuer une valeur par défaut, pour une lecture facile d'une ligne, vous pouvez souvent le faire:

elem = elem || defaultElem;

C'est souvent une bonne chose à utiliser, voir: Manière idiomatique de définir la valeur par défaut en javascript

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

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

vous pouvez utiliser l' typeofopérateur.

Par exemple,

var dataSet;

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

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

variable dataSet est: non défini.

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

Je n'ai pas trouvé de moyen d'extraire le code d'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");
}

Ces réponses (à l'exception de la solution Fred Gandt) sont toutes soit incorrectes soit incomplètes.

Supposons que j'ai besoin de mon variableName;pour porter une undefinedvaleur, et donc qu'elle a été déclarée d'une manière telle que var variableName;cela signifie qu'elle est déjà initialisée ; - Comment vérifier si c'est déjà déclaré?

Ou encore mieux - comment puis-je vérifier immédiatement si "Book1.chapter22. paragraph37" existe avec un seul appel, mais ne génère pas d'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

À une époque de popularité croissante d'AJAX, j'ai écrit une méthode (nommé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 bien plus encore.

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 posterai pas ici mais je fournirai des mots clés ( javascript + isNS ) qui vous aideront à localiser le code source, soutenu par tous les 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.

Veuillez noter que nous recherchons consoleuniquement dans la portée globale (qui est un windowobjet dans tous les navigateurs). Dans cette situation particulière, c'est souhaitable. Nous ne voulons pas de consoledéfinition ailleurs.

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

J'utilise deux façons différentes selon l'objet.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

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 de l'opposé, alors dans la première instance! Variable devient !! variable, et dans la fonction invalide === devenez! = Et le nom de la fonction devient notInvalid.

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

Quel que soit votre choix, pensez à placer 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 parfois être une propriété imbriquée. 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 génère pas d'erreur.

Ou vous pouvez utiliser existy comme existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Ç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'une égalité stricte, typeof renvoie toujours une chaîne.) Mais si vous avez des arguments à une fonction qui peuvent ou non avoir été passés, 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"

Try-catch

Si la variable n'a pas été définie du tout, vous pouvez vérifier cela sans interrompre l'exécution du code en utilisant le bloc try-catch comme suit (vous n'avez pas besoin de use strictmode)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (se référant à d'autres réponses) Pourquoi ===est plus clair que ==( source )

si (a == b)

si (a === b)

Je suis surpris que cela n'ait pas encore été mentionné ...

voici quelques variantes supplémentaires en utilisant this['var_name']

l'avantage d'utiliser cette méthode qui peut être utilisée avant la définition d'une variable.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Vous pouvez utiliser un bloc try ... catch comme suit:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Un inconvénient est que vous ne pouvez pas le mettre dans une fonction car cela lancerait une ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))