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

1282
2018-02-25 03:44


origine


Réponses:


Tu veux la typeof opérateur. Plus précisément:

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

2503
2018-02-06 04:56



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

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

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

Cependant, notez que typeof null reviendra "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 d'égalité simple ==, voir:
Quel opérateur égal (== vs ===) devrait être utilisé dans les comparaisons JavaScript?


692
2018-06-28 16:00



En JavaScript, une variable peut être définie, mais conserver la valeur undefined, donc la réponse la plus commune n'est pas techniquement correcte, et effectue plutôt 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 courez dans un navigateur (où window est un nom pour l'objet global). Mais si vous utilisez des globals comme ça, vous êtes probablement dans un navigateur. Subjectivement, en utilisant 'name' in window est stylistiquement compatible avec l'utilisation window.name pour se référer aux globaux. Accéder aux globals en tant que propriétés de window plutôt que sous forme de 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 du lissage), et évite la possibilité que votre variable globale soit ombrée par une variable locale. 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.


182
2017-10-22 15:47



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 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ées comme des valeurs "par défaut" (donc équivalentes à undefined ou null).

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

    • C'est le seul contrôle ne jettera pas une erreur si elem n'est pas déclaré (c'est-à-dire var déclaration, pas une propriété de windowou pas 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) ...

Cependant, parce que le global undefinedpeut être surchargé avec 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 minis de JS peuvent réduire la undefined variable à un seul caractère, vous économisant quelques octets à chaque fois.


112
2018-02-25 03:48



Dans de nombreux cas, en utilisant:

if (elem) { // or !elem

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

  1. indéfini: si la valeur n'est pas définie et c'est undefined
  2. nul: 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

Donc, ça couvrira un peu tous les cas, mais il y a toujours des cas bizarres que nous aimerions couvrir, par exemple, une corde avec des espaces, comme ça ' ' un, ceci sera défini dans javascript car il 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()) {
///

En outre, ces contrôles sont pour valeurs uniquement, car les objets et les tableaux fonctionnent différemment en Javascript, tableau vide [] et objet vide {} sont toujours vrai.

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

undefined, null, etc


80
2017-09-01 06:15



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 variable foo n'a pas été défini, car vous ne pouvez pas transmettre une variable inexistante à une fonction:

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


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

Alors que notre isset La fonction ne peut pas être utilisée pour tester si une variable existe ou non (pour des 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 est passé le long de fonctionner test, notre isset fonction fonctionne parfaitement dans ce contexte, car y est connu en fonction test en tant que undefined valeur.


59
2018-02-19 11:54



Vérifier si un objet hasOwnProperty()

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

le hasOwnProperty() method 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 descendu de Objet hérite du hasOwnProperty() méthode. 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 à dans opérateur, 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-ce en l'appelant, nous n'utilisons pas une variable qui pourrait encore être indéfini - ce qui, bien sûr, est la moitié du problème en premier lieu.

Bien que non toujours la parfait ou idéal solution, dans certaines circonstances, c'est juste le travail!


42
2018-05-02 14:07



Il existe une autre méthode à court terme pour vérifier cela, lorsque vous effectuez des affectations simples et des vérifications connexes. Simplement utiliser Opérateur conditionnel (ternaire).

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

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

Si vous voulez vérifier la variable ne devrait 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 il effectuerait undefined et null vérifie ensemble.

var values = variable ? variable : '';

38
2018-02-19 05:26



undefined, boolean, string, nombre, fonction

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

}

Objet, tableau

if( foo instanceof Array ) { 

}

27
2017-07-26 02:08