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


Answers

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?

Question

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



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.




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.




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




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;



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




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!




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:




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
}



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.




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
}