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

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

dans JavaScript, une variable peut être définie, mais avoir la valeur undefined , de sorte que 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
}

qui peut suffire à vos fins. Le test suivant a une sémantique plus simple, ce qui rend plus facile de décrire précisément le comportement de votre code et de le comprendre 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
}

cela, bien sûr, suppose que vous s'exécutant dans un navigateur (où window est un nom pour l'objet global). Mais si vous vous baladez avec des globals comme celui-ci, vous êtes probablement dans un navigateur. Subjectivement, utiliser 'name' in window est stylistiquement compatible avec l'utilisation de window.name pour faire référence aux globals. L'accès aux globals en tant que propriétés de window plutôt que comme variables vous permet de minimiser le nombre de variables non déclarées que vous référez dans votre code (pour le bénéfice de linting), et évite la possibilité de votre être global de l'ombre à une variable locale. Aussi, si globals rendre votre peau ramper vous pourriez vous sentir plus à l'aise qu'avec cette relativement long bâton.

dans la majorité des cas vous utiliseriez:

elem != null

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

les autres contrôles ne sont pas incorrects non plus, ils ont juste des utilisations différentes:

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

• typeof elem == 'undefined' peut être utilisé dans les cas où un null spécifié a un sens distinct pour une variable ou un bien non initialisé.

  • C'est le seul contrôle que ne lancera pas d'erreur si elem n'est pas déclaré (c.-à-d. pas de déclaration var , pas une propriété de window , ou pas un argument de fonction). C'est, à mon avis, assez dangereux car cela permet aux fautes de frappe de passer inaperçues. Pour éviter cela, voir la méthode ci-dessous.

aussi utile est une comparaison stricte contre undefined :

if (elem === undefined) ...

cependant, parce que le global undefined peut être dépassé avec une autre valeur, il est préférable de déclarer la variable undefined dans le champ d'application actuel 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 minifieurs JS peuvent réduire la variable undefined à un seul caractère, vous économisant quelques octets à chaque fois.

dans de nombreux cas, en utilisant:

if (elem) { // or !elem

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

1. Non défini : si la valeur n'est pas définie et il est undefined
2. null : si elle est nulle, par exemple, si un élément DOM n'existe pas...
3. chaîne vide : ''
4. 0 : nombre 0
5. NaN : pas un numéro
6. false

donc il couvrira un peu tous les cas, mais il y a toujours des cas bizarres que nous aimerions couvrir aussi, par exemple, une chaîne avec des espaces, comme celui-ci ' ' , cela sera défini en javascript car il a des espaces à l'intérieur de la chaîne... par exemple, dans ce cas vous ajoutez un contrôle supplémentaire en utilisant trim (), comme:

if(elem) {

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

aussi, ces vérifications sont pour valeurs seulement, comme les objets et les tableaux fonctionnent différemment dans Javascript, tableau vide [] et objet vide {} sont toujours vrai .

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

Comment vérifier si une variable existe

c'est une solution assez pare-balles pour tester si une variable existe et a été initialisé:

var setOrNot = typeof variable !== typeof undefined;

il est le plus couramment 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 eg. isset(foo) et la variable foo n'a pas été définie, parce que vous ne pouvez pas passer le long d'une variable non existante à une fonction:

Uncaught ReferenceError: foo n'est pas défini

Tester si les paramètres de la fonction sont undefined

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

var a = '5';

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

test(a);

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

bien qu'aucune valeur pour y ne soit transmise à la fonction test , notre isset la fonction fonctionne parfaitement dans ce contexte, parce que y est connu dans la fonction test 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é i.e. 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 propre (non hérité) propriété.

tout objet descendant de objet hérite de la méthode hasOwnProperty() . Cette méthode peut être utilisée pour déterminer si un objet possède la propriété spécifiée comme propriété directe de cet objet; contrairement à l'opérateur de , 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 hasOwnProperty() , c'est qu'en l'appelant, nous n'utilisons pas une variable qui pourrait encore être non définie - ce qui est bien sûr la moitié du problème en premier lieu.

bien que pas toujours le parfait ou idéal solution, dans certaines circonstances, c'est juste le travail!

il y a un autre moyen manuel court pour vérifier cela, lorsque vous effectuez des tâches simples et des vérifications connexes. Il suffit d'utiliser L'opérateur conditionnel (ternaire).

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

ce sera également utile, lorsque vous essayez de déclarer la variable globale avec assignation d'instance de la variable de référence.

si vous voulez cocher la variable ne devrait pas être undefined ou null . Effectuez ensuite ci-dessous chèque.

lorsque la variable est déclarée, et si vous voulez vérifier la valeur, c'est même Simple: et il effectuerait des vérifications undefined et null ensemble.

var values = variable ? variable : '';

undefined,booléen,chaîne de caractères,nombre,fonction

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

}

Object, Array

if( foo instanceof Array ) { 

}

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.

=== null ou !== null seulement si la valeur de la variable est exactement null .

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

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

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 quelque raison Impie). Ainsi, le simple fait de faire un contrôle pour varName !== undefined a le potentiel de ne pas toujours revenir comme vous l'attendez, parce que d'autres libs pourraient avoir changé non défini. Quelques réponses (@skalee's, par exemple), semblent préférer ne pas utiliser typeof , ce qui pourrait causer des problèmes.

Le "vieux" la façon de gérer cela était de déclarer non défini comme un var pour compenser tout potentiel mutage/over-riding de undefined . Cependant, la meilleure façon est encore d'utiliser typeof parce qu'il ignorera toute dérogation de undefined à partir d'un autre code. Surtout si vous écrivez du code à utiliser dans la nature où qui sait quoi d'autre pourrait courir 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) , donc vérifier si son falsy. Cela peut apporter au code plus propre de sorte 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 attribuer à une variable lorsque vous voulez indiquer que la variable n'a pas de valeur particulière. Non défini est une valeur spéciale qui sera la valeur par défaut des variables non assigné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 retourne "object"

par conséquent, la réponse acceptée ne fonctionnera pas si vous passez les valeurs nulles. Si vous réussissez les valeurs null, vous devez ajouter un contrôle supplémentaire pour les valeurs null:

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

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

supposez que j'ai besoin de mon variableName; pour porter une valeur undefined , et donc 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 s'il est déjà déclaré?

ou même mieux - comment vérifier immédiatement si" Book1.chapter22.paragraph37" existe, avec une 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 dans .:

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

dans les temps de pointe de popularité AJAX j'ai écrit une méthode (plus tard nommée) isNS() qui est capable de déterminer si l'Espace-nom existe, y compris des tests profonds pour les noms de propriétés telles que" Book1.chapter22.paragraphe37" et bien plus encore.

mais depuis qu'il a été précédemment 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 fournira des mots-clés ( javascript + isNS ) qui vous aideront à localiser le code source, soutenu avec toutes les explications nécessaires.

le contrôle le plus robuste" est-il défini "est avec type de

if (typeof elem === 'undefined')

si vous vérifiez simplement qu'une variable définie affecte une valeur par défaut, pour un liner facile à lire vous pouvez souvent faire ceci:

elem = elem || defaultElem;

c'est souvent bien d'utiliser, voir: façon idiomatique de définir la valeur par défaut dans javascript

il y a aussi cette doublure qui utilise le type mot clé:

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

vous pouvez utiliser l'opérateur typeof .

par exemple,

var dataSet;

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

au-dessus de code snippet retournera la sortie comme

ensemble de données variables est: non défini.

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 ne recherchons console que 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 que console soit défini ailleurs.

@BrianKelley dans son grande réponse explique les détails techniques. J'ai seulement ajouté le manque de conclusion et l'ai digéré dans quelque chose plus facile à lire.

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

peu importe comment vous choisissez, envisagez de mettre le contrôle dans une fonction comme so

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;

si vous savez que la variable est déclarée mais peut ne pas être existante, 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 || {} aller en bas de la ligne de vérification de l'existence de la propriété en question:

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

après chaque utilisation de biens (...'/ / {}').nextProp pour qu'une propriété manquante ne déclenche pas d'erreur.

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

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

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

si vous voulez que le bloc non défini fasse quelque chose ou assignez ou définissez la variable alors utilisez ce

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

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 du contraire, alors en premier lieu !la variable devient !!variable, et dans la fonction invalide = = = devenir != et les noms de fonction changent en notInvalid.

cela dépend de la situation. Si vous cherchez quelque chose qui pourrait 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, 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 nuls s'ils ont été omis.

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

Un peu plus fonctionnel et facile à utiliser:

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

la fonction retournera vrai s'il existe, sinon faux s'il n'existe pas.

que dire d'un simple:

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

soyez conscient que lorsque vous vérifiez !== ou != contre "non défini" il ne fonctionnera pas

testé sur Firfox Quantom 60.0.1

utilisez le test comme ceci à la place pour éviter les conflits

if(!(typeof varibl['fl'] === 'undefined')) {

            console.log(varibl['fl']);
            console.log("Variable is Defined");
        }else{

            console.log(varibl['fl']);
            console.log("Variable is Un-Defined");
        }

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

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

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 true IFF x est soit null ou Non défini , donc !!x ne renvoie true ssi x est ni indéfini, ni nulle.

je me rends compte que cela explique aussi le cas nul, mais voici un avertissement à ce sujet.