Quelle est la meilleure façon de vérifier si une propriété d'objet en JavaScript est undefined?

La façon habituelle de vérifier si la valeur d'une propriété est la valeur spéciale undefinedest la suivante:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

Pour vérifier si un objet ne possède pas réellement une telle propriété, et reviendra donc undefinedpar défaut lorsque vous essayez d'y accéder:

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

Pour vérifier si la valeur associée à un identifiant est la valeur spéciale undefined, ou si cet identifiant n'a pas été déclaré. Remarque: cette méthode est la seule façon de se référer à un identifiant non déclaré (note: différent d'avoir une valeur de undefined) sans erreur précoce:

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

Dans les versions de JavaScript antérieures à ECMAScript 5, la propriété nommée "undefined" sur l'objet global était accessible en écriture, et par conséquent une simple vérification foo === undefinedpouvait se comporter de manière inattendue si elle avait été accidentellement redéfinie. En JavaScript moderne, la propriété est en lecture seule.

Cependant, dans JavaScript moderne, "undefined" n'est pas un mot-clé, et donc les variables à l'intérieur des fonctions peuvent être nommées "undefined" et masquer la propriété globale.

Si vous êtes préoccupé par ce cas de bord (peu probable), vous pouvez utiliser l'opérateur void pour obtenir la undefinedvaleur spéciale elle-même:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

Je pense qu'il existe un certain nombre de réponses incorrectes à ce sujet. Contrairement à la croyance courante, "non défini" n'est pas un mot clé en JavaScript et peut en fait avoir une valeur qui lui est affectée.

Code correct

La façon la plus robuste d'effectuer ce test est:

if (typeof myVar === "undefined")

Cela retournera toujours le résultat correct et gère même la situation où myVarn'est pas déclaré.

Code dégénéré. NE PAS UTILISER.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

En outre, myVar === undefinedgénérera une erreur dans la situation où myVar n'est pas déclaré.

Bien qu'il soit vivement recommandé par de nombreuses autres réponses ici, typeof c'est un mauvais choix . Il ne doit jamais être utilisé pour vérifier si les variables ont la valeur undefined, car il agit comme une vérification combinée de la valeur undefinedet si une variable existe. Dans la grande majorité des cas, vous savez quand une variable existe, et vous typeofintroduirez simplement le potentiel d'un échec silencieux si vous faites une faute de frappe dans le nom de la variable ou dans le littéral de chaîne 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

Donc, à moins que vous ne fassiez de la détection de fonctionnalités², où il y a une incertitude quant à la portée d'un nom donné (comme la vérification en typeof module !== 'undefined'tant qu'étape de code spécifique à un environnement CommonJS), typeofest un choix nuisible lorsqu'il est utilisé sur une variable, et l'option correcte est pour comparer directement la valeur:

var foo = …;

if (foo === undefined) {
    ⋮
}

Voici quelques idées fausses courantes à ce sujet:

• que la lecture d'une variable ( var foo) ou d'un paramètre (non function bar(foo) { … }appelé bar()) (non appelé ) échouera. Ce n'est tout simplement pas vrai - les variables sans initialisation explicite et les paramètres qui n'ont pas reçu de valeurs deviennent toujours undefined, et sont toujours dans la portée.

• qui undefinedpeut être écrasé. Il y a beaucoup plus à cela. undefinedn'est pas un mot clé en JavaScript. Au lieu de cela, c'est une propriété sur l'objet global avec la valeur Undefined. Cependant, depuis ES5, cette propriété est en lecture seule et non configurable . Aucun navigateur moderne ne permettra de modifier la undefinedpropriété, et depuis 2017, cela a été le cas depuis longtemps. Le manque de mode strict n'affecte pas non plus undefinedle comportement de - il fait juste des instructions comme undefined = 5ne rien faire au lieu de lancer. Comme il ne s'agit pas d'un mot clé, vous pouvez déclarer des variables avec le nom undefined, et ces variables peuvent être modifiées, ce qui rend ce modèle autrefois commun:

  (function (undefined) {
      // …
  })()

  plus dangereux que d'utiliser le global undefined. Si vous devez être compatible ES3, remplacez-le undefinedpar void 0- ne pas y recourir typeof. ( voida toujours été un opérateur unaire qui évalue la valeur non définie pour n'importe quel opérande.)

Avec la façon dont les variables fonctionnent, il est temps de répondre à la question réelle: les propriétés des objets. Il n'y a aucune raison de jamais utiliser typeofpour les propriétés d'objet. L'exception précédente concernant la détection des fonctionnalités ne s'applique pas ici - typeofn'a qu'un comportement spécial sur les variables, et les expressions qui font référence aux propriétés des objets ne sont pas des variables.

Cette:

if (typeof foo.bar === 'undefined') {
    ⋮
}

est toujours exactement équivalent à ceci³:

if (foo.bar === undefined) {
    ⋮
}

et en tenant compte des conseils ci-dessus, pour éviter de confondre les lecteurs quant à la raison pour laquelle vous utilisez typeof, car il est plus judicieux d'utiliser ===pour vérifier l'égalité, car il pourrait être remanié pour vérifier la valeur d'une variable plus tard, et parce qu'il est tout simplement clair semble mieux, vous devriez toujours utiliser === undefined³ ici aussi .

Une autre chose à considérer en ce qui concerne les propriétés des objets est de savoir si vous voulez vraiment vérifier undefined. Un nom de propriété donné peut être absent sur un objet (produisant la valeur undefinedlors de la lecture), présent sur l'objet lui-même avec la valeur undefined, présent sur le prototype de l'objet avec la valeur undefined, ou présent sur l'un de ceux avec une non- undefinedvaleur. 'key' in objvous dira si une clé se trouve n'importe où sur la chaîne de prototype d'un objet et Object.prototype.hasOwnProperty.call(obj, 'key')vous dira si elle se trouve directement sur l'objet. Je n'entrerai pas dans les détails dans cette réponse sur les prototypes et l'utilisation d'objets comme cartes à chaînes de caractères, car cela est principalement destiné à contrer tous les mauvais conseils dans les autres réponses, quelles que soient les interprétations possibles de la question d'origine. Lire surprototypes d'objets sur MDN pour plus!

_{¹ choix inhabituel d'exemple de nom de variable? c'est du vrai code mort de l'extension NoScript pour Firefox.
² ne présumez pas que ne pas savoir ce qui est dans la portée est bien en général, cependant. vulnérabilité supplémentaire causée par un abus de portée dynamique: Project Zero 1225
³ supposant une fois de plus un environnement ES5 + et qui se undefinedréfère à la undefinedpropriété de l'objet global. remplacer void 0autrement.}

En JavaScript, il y a null et il n'y a pas de définition . Ils ont des significations différentes.

• undefined signifie que la valeur de la variable n'a pas été définie; on ne sait pas quelle est la valeur.
• null signifie que la valeur de la variable est définie et définie sur null (n'a pas de valeur).

Marijn Haverbeke déclare, dans son livre en ligne gratuit " Eloquent JavaScript " (c'est moi qui souligne):

Il existe également une valeur similaire, null, dont la signification est «cette valeur est définie, mais elle n'a pas de valeur». La différence de sens entre indéfini et nul est principalement académique et généralement peu intéressante. Dans les programmes pratiques, il est souvent nécessaire de vérifier si quelque chose «a une valeur». Dans ces cas, l'expression quelque chose == undefined peut être utilisée, car, même si elles ne sont pas exactement la même valeur, null == undefined produira true.

Donc, je suppose que la meilleure façon de vérifier si quelque chose n'était pas défini serait:

if (something == undefined)

J'espère que cela t'aides!

Modifier: En réponse à votre modification, les propriétés des objets devraient fonctionner de la même manière.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

Qu'est-ce que cela signifie: "propriété d'objet non définie" ?

En fait, cela peut signifier deux choses bien différentes! Premièrement, cela peut signifier la propriété qui n'a jamais été définie dans l'objet et, deuxièmement, cela peut signifier la propriété qui a une valeur indéfinie . Regardons ce code:

var o = { a: undefined }

Est o.aindéfini? Oui! Sa valeur n'est pas définie. Est o.bindéfini? Sûr! Il n'y a aucune propriété «b» du tout! OK, voyez maintenant comment les différentes approches se comportent dans les deux situations:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

Nous pouvons clairement voir cela typeof obj.prop == 'undefined'etobj.prop === undefined sont équivalents, et ils ne distinguent pas ces différentes situations. Et 'prop' in objpeut détecter la situation où une propriété n'a pas été définie du tout et ne fait pas attention à la valeur de la propriété qui peut être indéfinie.

Alors que faire?

1) Vous voulez savoir si une propriété n'est pas définie par la première ou la deuxième signification (la situation la plus typique).

obj.prop === undefined // IMHO, see "final fight" below

2) Vous voulez simplement savoir si l'objet a une propriété et ne vous souciez pas de sa valeur.

'prop' in obj

Remarques:

• Vous ne pouvez pas vérifier un objet et sa propriété en même temps. Par exemple, ceci x.a === undefinedou cela typeof x.a == 'undefined'augmente ReferenceError: x is not definedsi x n'est pas défini.
• La variable undefinedest une variable globale (elle se trouve donc window.undefineddans les navigateurs). Il est pris en charge depuis ECMAScript 1st Edition et depuis ECMAScript 5, il est en lecture seule . Donc, dans les navigateurs modernes, cela ne peut pas être redéfini sur vrai car de nombreux auteurs aiment nous faire peur, mais cela reste vrai pour les navigateurs plus anciens.

Combat final: obj.prop === undefined vstypeof obj.prop == 'undefined'

Avantages de obj.prop === undefined:

• Il est un peu plus court et semble un peu plus joli
• Le moteur JavaScript vous donnera une erreur si vous avez mal orthographié undefined

Moins de obj.prop === undefined:

• undefined peut être remplacé dans les anciens navigateurs

Avantages de typeof obj.prop == 'undefined':

• C'est vraiment universel! Il fonctionne dans les nouveaux et anciens navigateurs.

Moins de typeof obj.prop == 'undefined':

• 'undefned'( mal orthographié ) voici juste une constante de chaîne, donc le moteur JavaScript ne peut pas vous aider si vous l'avez mal orthographié comme je viens de le faire.

Mise à jour (pour JavaScript côté serveur):

Node.js prend en charge la variable globale undefinedas global.undefined(elle peut également être utilisée sans le préfixe «global»). Je ne connais pas les autres implémentations de JavaScript côté serveur.

Le problème se résume à trois cas:

1. L'objet a la propriété et sa valeur ne l'est pas undefined.
2. L'objet a la propriété et sa valeur est undefined.
3. L'objet n'a pas la propriété.

Cela nous dit quelque chose que je considère important:

Il existe une différence entre un membre non défini et un membre défini avec une valeur non définie.

Mais malheureusement, typeof obj.foone nous dit pas lequel des trois cas nous avons. Cependant, nous pouvons combiner cela avec "foo" in objpour distinguer les cas.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

Il convient de noter que ces tests sont également les mêmes pour les nullentrées

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

Je dirais que dans certains cas, il est plus logique (et plus clair) de vérifier si la propriété est là, que de vérifier si elle n'est pas définie, et le seul cas où cette vérification sera différente est le cas 2, le rare cas de une entrée réelle dans l'objet avec une valeur non définie.

Par exemple: je viens de refactoriser un tas de code qui avait un tas de vérifications si un objet avait une propriété donnée.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

Ce qui était plus clair lorsqu'il était écrit sans vérification pour indéfini.

if( "x" in blob ) { fn(blob.x); }

Mais comme cela a été mentionné, ce ne sont pas exactement les mêmes (mais ils sont plus que suffisants pour mes besoins).

if ( typeof( something ) == "undefined") 

Cela a fonctionné pour moi tandis que les autres ne l'ont pas fait.

Je ne sais pas d'où vient l'utilisation de ===with typeof, et comme convention je le vois utilisé dans de nombreuses bibliothèques, mais l'opérateur typeof renvoie un littéral de chaîne, et nous le savons d'avance, alors pourquoi voudriez-vous également taper vérifier aussi?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

Crossposting ma réponse à partir d'une question connexe Comment vérifier si "non défini" en JavaScript?

Spécifique à cette question, voir les cas de test avec someObject.<whatever>.

Quelques scénarios illustrant les résultats des différentes réponses: http://jsfiddle.net/drzaus/UVjM4/

(Notez que l'utilisation de varpour les intests fait une différence dans un wrapper de portée)

Code de référence:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

Et les résultats:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

Si tu fais

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

il échouera lorsque la variable myvar n'existe pas, car myvar n'est pas défini, donc le script est cassé et le test n'a aucun effet.

Étant donné que l'objet fenêtre a une portée globale (objet par défaut) en dehors d'une fonction, une déclaration sera «attachée» à l'objet fenêtre.

Par exemple:

var myvar = 'test';

La variable globale myvar est la même que window.myvar ou window ['myvar']

Pour éviter les erreurs de test lorsqu'une variable globale existe, il vaut mieux utiliser:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

La question de savoir si une variable existe vraiment n'a pas d'importance, sa valeur est incorrecte. Sinon, il est stupide d'initialiser des variables avec undefined, et il vaut mieux utiliser la valeur false pour initialiser. Lorsque vous savez que toutes les variables que vous déclarez sont initialisées avec false, vous pouvez simplement vérifier son type ou vous fier !window.myvarà vérifier si elle a une valeur correcte / valide. Ainsi, même lorsque la variable n'est pas définie, il en !window.myvarva de même pour myvar = undefinedou myvar = falseoumyvar = 0 .

Lorsque vous attendez un type spécifique, testez le type de la variable. Pour accélérer le test d'une condition, il vaut mieux:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

Lorsque la première et simple condition est remplie, l'interpréteur ignore les tests suivants.

Il est toujours préférable d'utiliser l'instance / l'objet de la variable pour vérifier si elle a obtenu une valeur valide. Il est plus stable et constitue un meilleur moyen de programmation.

(y)

Je n'ai vu (j'espère pas l'avoir manqué) quiconque vérifier l'objet avant la propriété. C'est donc le plus court et le plus efficace (mais pas forcément le plus clair):

if (obj && obj.prop) {
  // Do something;
}

Si obj ou obj.prop est indéfini, nul ou "falsifié", l'instruction if n'exécutera pas le bloc de code. Il s'agit généralement du comportement souhaité dans la plupart des instructions de bloc de code (en JavaScript).

Dans l'article Exploring the Abyss of Null and Undefined in JavaScript, j'ai lu que les frameworks comme Underscore.js utilisent cette fonction:

function isUndefined(obj){
    return obj === void 0;
}

Tout simplement, tout n'est pas défini en JavaScript, n'est pas défini , peu importe qu'il s'agisse d'une propriété à l'intérieur d'un objet / tableau ou simplement d'une simple variable ...

JavaScript a typeofqui le rend très facile à détecter une variable non définie.

Vérifiez simplement si typeof whatever === 'undefined'et cela renverra un booléen.

C'est ainsi que la célèbre fonction isUndefined()d'AngularJs v.1x s'écrit:

function isUndefined(value) {return typeof value === 'undefined';} 

Donc, comme vous voyez que la fonction reçoit une valeur, si cette valeur est définie, elle retournera false, sinon pour les valeurs non définies, retournera true.

Voyons donc quels seront les résultats lorsque nous passerons des valeurs, y compris les propriétés des objets comme ci-dessous, voici la liste des variables que nous avons:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

et nous les vérifions comme ci-dessous, vous pouvez voir les résultats devant eux sous forme de commentaire:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

Comme vous le voyez, nous pouvons tout vérifier en utilisant quelque chose comme ça dans notre code, comme mentionné, vous pouvez simplement l'utiliser typeofdans votre code, mais si vous l'utilisez encore et encore, créez une fonction comme l'exemple angulaire que je partage et continue à réutiliser comme suivant le modèle de code DRY.

Encore une chose, pour vérifier la propriété d'un objet dans une application réelle dont vous n'êtes pas sûr que l'objet existe ou non, vérifiez si l'objet existe en premier.

Si vous vérifiez une propriété sur un objet et que cet objet n’existe pas, une erreur se produit et l’application entière s'arrête.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

Si simple que vous pouvez envelopper une instruction if comme ci-dessous:

if(typeof x !== 'undefined') {
  //do something
}

Qui est également égal à isDefined dans Angular 1.x ...

function isDefined(value) {return typeof value !== 'undefined';}

D'autres frameworks javascript comme le soulignement ont également une vérification de définition similaire, mais je vous recommande d'utiliser typeofsi vous n'utilisez déjà aucun framework.

J'ajoute également cette section de MDN qui a obtenu des informations utiles sur typeof, undefined et void (0).

Égalité stricte et non défini
Vous pouvez utiliser les opérateurs undefined et stricte d'égalité et d'inégalité pour déterminer si une variable a une valeur. Dans le code suivant, la variable x n'est pas définie et l'instruction if prend la valeur true.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Remarque: L'opérateur d'égalité stricte plutôt que l'opérateur d'égalité standard doit être utilisé ici, car x == non défini vérifie également si x est nul, contrairement à l'égalité stricte. null n'est pas équivalent à undefined. Voir les opérateurs de comparaison pour plus de détails.

Opérateur typeof et indéfini
Alternativement, typeof peut être utilisé:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

L'une des raisons d'utiliser typeof est qu'il ne génère pas d'erreur si la variable n'a pas été déclarée.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

Cependant, ce type de technique doit être évité. JavaScript est un langage à portée statique, donc savoir si une variable est déclarée peut être lu en voyant si elle est déclarée dans un contexte englobant. La seule exception est la portée globale, mais la portée globale est liée à l'objet global, donc la vérification de l'existence d'une variable dans le contexte global peut être effectuée en vérifiant l'existence d'une propriété sur l'objet global (en utilisant l'opérateur in, par exemple).

Opérateur nul et non défini

L'opérateur void est une troisième alternative.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

plus> ici

' if (window.x) {} ' est protégé contre les erreurs

Vous le souhaitez très probablement if (window.x). Cette vérification est sûre même si x n'a pas été déclaré ( var x;) - le navigateur ne génère pas d'erreur.

Exemple: je veux savoir si mon navigateur prend en charge l'API Historique

if (window.history) {
    history.call_some_function();
}

Comment cela fonctionne:

window est un objet qui contient toutes les variables globales en tant que membres, et il est légal d'essayer d'accéder à un membre inexistant. Si x n'a pas été déclaré ou n'a pas été défini, window.xretourne undefined . undefined conduit à false lorsque if () l' évalue.

En lisant ceci, je suis étonné de ne pas l'avoir vu. J'ai trouvé plusieurs algorithmes qui fonctionneraient pour cela.

Jamais défini

Si la valeur d'un objet n'a jamais été définie, cela empêchera de revenir trues'il est défini comme nullou undefined. Cela est utile si vous souhaitez que true soit renvoyé pour les valeurs définies commeundefined

if(obj.prop === void 0) console.log("The value has never been defined");

Défini comme indéfini ou jamais défini

Si vous voulez que cela résulte comme truepour les valeurs définies avec la valeur de undefined, ou jamais définies, vous pouvez simplement utiliser=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

Défini comme une valeur falsifiée, non défini, nul ou jamais défini.

Généralement, les gens m'ont demandé un algorithme pour déterminer si une valeur est soit fausse undefined, soit null. Les œuvres suivantes.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

Comparez avec void 0, pour la concision.

if (foo !== void 0)

Ce n'est pas aussi verbeux que if (typeof foo !== 'undefined')

La solution est incorrecte. En JavaScript,

null == undefined

retournera vrai, car ils sont tous les deux "castés" en booléens et sont faux. La bonne façon serait de vérifier

if (something === undefined)

qui est l'opérateur d'identité ...

Vous pouvez obtenir un tableau non défini avec chemin à l'aide du code suivant.

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

Lien jsFiddle

Voici ma situation:

J'utilise le résultat d'un appel REST. Le résultat doit être analysé à partir de JSON vers un objet JavaScript.

Il y a une erreur que je dois défendre. Si les arguments de l'appel de repos étaient incorrects dans la mesure où l'utilisateur spécifiant les arguments de manière incorrecte, l'appel de repos revient essentiellement vide.

En utilisant ce post pour m'aider à me défendre contre cela, j'ai essayé cela.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

Pour ma situation, si restResult.data [0] === "objet", alors je peux commencer en toute sécurité à inspecter le reste des membres. Si non défini, lancez l'erreur comme ci-dessus.

Ce que je dis, c'est que pour ma situation, toutes les suggestions ci-dessus dans ce post n'ont pas fonctionné. Je ne dis pas que j'ai raison et que tout le monde a tort. Je ne suis pas du tout un maître JavaScript, mais j'espère que cela aidera quelqu'un.

Il existe un moyen agréable et élégant d’attribuer une propriété définie à une nouvelle variable si elle est définie ou de lui attribuer une valeur par défaut comme solution de rechange si elle n’est pas définie.

var a = obj.prop || defaultValue;

Cela convient si vous avez une fonction, qui reçoit une propriété de configuration supplémentaire:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

En cours d'exécution

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Toutes les réponses sont incomplètes. C'est la bonne façon de savoir qu'il existe une propriété «définie comme non définie»:

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

Exemple:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

Dommage que cela ait été la bonne réponse est enterré dans de mauvaises réponses> _ <

Donc, pour tous ceux qui passeront, je vous donnerai des indéfinis gratuitement !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

En parcourant les commentaires, pour ceux qui veulent vérifier les deux, c'est indéfini ou sa valeur est nulle:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

Si vous utilisez la bibliothèque jQuery, jQuery.isEmptyObject()cela suffira dans les deux cas,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

Si vous utilisez Angular:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

J'utilise if (this.variable)pour tester s'il est défini. Simple if (variable), recommandé ci - dessus , échoue pour moi. Il s'avère que cela ne fonctionne que lorsque la variable est un champ d'un objet, obj.someFieldpour vérifier si elle est définie dans le dictionnaire. Mais nous pouvons utiliser thisou windowcomme objet dictionnaire car toute variable est un champ dans la fenêtre actuelle, si je comprends bien. Voici donc un test

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

Il détecte d'abord que la variable abcn'est pas définie et elle est définie après l'initialisation.

Je propose ici trois façons pour ceux qui attendent des réponses étranges:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

Essayez d'obtenir une propriété de la valeur d'entrée, vérifiez le message d'erreur s'il existe. Si la valeur d'entrée n'est pas définie, le message d'erreur serait Uncaught TypeError: Impossible de lire la propriété «b» de non défini

isUndefined2:

Convertir la valeur d'entrée en chaîne pour comparer avec "undefined" et assurez-vous qu'il s'agit d'une valeur négative.

isUndefined3:

Dans js, le paramètre facultatif fonctionne lorsque la valeur d'entrée est exactement undefined.

ES2019 a introduit une nouvelle fonctionnalité - chaînage facultatif que vous pouvez utiliser pour utiliser une propriété d'un objet uniquement lorsqu'un objet est défini comme ceci:

const userPhone = user?.contactDetails?.phone;

Il fera référence à la propriété du téléphone uniquement lorsque l'utilisateur et contactDetails sont définis.

Réf. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Renvoie false si la variable est définie et true si n'est pas défini.

Utilisez ensuite:

if (isUnset(var)) {
  // initialize variable here
}

Je voudrais vous montrer quelque chose que j'utilise pour protéger la undefinedvariable:

Object.defineProperty(window, 'undefined', {});

Cela interdit à quiconque de modifier la window.undefinedvaleur, détruisant ainsi le code basé sur cette variable. Si vous utilisez "use strict", tout ce qui tente de changer sa valeur se terminera par erreur, sinon il serait ignoré en silence.

vous pouvez également utiliser Proxy, cela fonctionnera avec les appels imbriqués, mais nécessitera une vérification supplémentaire:

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

vous allez donc l'utiliser comme:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}