La détection d'une non défini propriété de l'objet en JavaScript

Question

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

Désolé, j'ai d'abord dit variable plutôt que la propriété de l'objet. Je crois que le même == undefined approche ne fonctionne pas.

Answer 1

Je crois qu'il y a un certain nombre de réponses incorrectes à ce sujet. Contrairement à la croyance commune "undefined" n'est PAS un mot-clé en javascript, et peut en fait avoir une valeur qui lui est assignée.

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

En outre, myVar === undefined déclenchera une erreur dans la situation où myVar est non déclaré.

Le plus robuste pour effectuer ce test est:

if(typeof myVar === "undefined")

Ce sera toujours le bon résultat, et même les poignées de la situation où myVar n'est pas déclaré.

Answer 2

En JavaScript, il est nul et il n'y est pas défini. Ils ont des significations différentes.

• indéfini signifie que la valeur de la variable n'a pas été défini; il ne sait pas quelle en est la valeur.
• null signifie que la valeur de la variable est définie et la valeur null (n'a pas de valeur).

Marijn Haverbeke unis, en sa gratuit, livre en ligne "Éloquent JavaScript" (l'emphase est mienne):

Il y a également une valeur similaire, null, dont le sens est 'cette valeur est définie, mais il n'a pas de valeur". La différence de sens entre indéfini et null est la plupart du temps scolaire, et généralement pas très intéressant. Dans la pratique, il est souvent nécessaire de vérifier si quelque chose a une valeur". Dans ces cas, l'expression de quelque chose == undefined peut être utilisé, parce que, même si elles ne sont pas exactement la même valeur, la valeur null == undefined retournera true.

Alors, je pense que la meilleure façon de vérifier si quelque chose d'indéfini serait:

if (something == undefined)

Espérons que cette aide!

Edit: En réponse à votre travail d'édition, les propriétés de l'objet devrait fonctionner de la même manière.

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

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

Answer 3

Ok. Qu'est-ce que cela signifie: "undefined propriété de l'objet"? En fait, il peut signifier deux choses tout à fait différentes! Tout d'abord, cela peut signifier que la propriété a jamais été définie dans l'objet et, deuxièmement, elle peut signifier la propriété qui a la valeur non définie. Nous allons voir à présent code:

var o = { a: undefined }

Est - o.a undefined? Oui! Sa valeur est undefined. Est - o.b undefined? Bien sûr! Il n'y a pas de propriété " b " à tous! Ok, voyons maintenant comment les différentes approches se comporter 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

Donc, nous pouvons clairement voir que, typeof obj.prop == 'undefined' et obj.prop === undefined sont équivalents et qu'ils ne font pas la distinction que des situations différentes. Et 'prop' in obj peut détecter la situation de la propriété n'a pas été définie à tous et ne faites pas attention à la valeur de la propriété qui peut être indéfini.

Alors, que faire?

1) Vous voulez savoir si la propriété n'est pas définie par le premier ou le deuxième sens (le plus typique de la situation).

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

2) Vous voulez juste savoir si l'objet a une propriété et ne se soucient pas de sa valeur.

'prop' in obj

Notes:

• Vous ne pouvez pas vérifier objet et de ses biens dans le même temps. Par exemple, cette x.a === undefined ou cette typeof x.a == 'undefined' soulève ReferenceError: x is not defined si x n'est pas définie.
• Variable undefined est une variable globale (donc, en fait, c'est - window.undefined dans les navigateurs). Il est pris en charge depuis ECMAScript 1ère Édition et depuis ECMAScript 5, il est en lecture seule. Donc dans les navigateurs modernes, il ne peut pas être redéfini pour vrai comme de nombreux auteurs l'amour nous fait peur mais c'est toujours un vrai pour les anciens navigateurs.

Final fight: obj.prop === undefined vs typeof obj.prop == 'undefined'

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

• c'est un peu plus courte et la regarde d'un peu plus joli
• js moteur vous donnera une erreur si vous avez mal orthographié undefined

Inconvénients obj.prop === undefined:

• undefined peut être remplacée dans les vieux navigateurs

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

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

Inconvénients typeof obj.prop == 'undefined':

• 'undefned' ici est juste une chaîne constante, de sorte que js moteur ne peut pas vous aider si vous avez mal orthographié comme je viens de le faire

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

Node.js prend en charge globale de la variable undefined comme global.undefined (peut également être utilisé sans "mondiale" de préfixe). Je ne sais pas pour les autres implémentations de serveur de côté JS.

Answer 4

La question se résume à trois cas:

1. L'objet a la propriété et sa valeur n'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 importantes:

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

Mais malheureusement, typeof obj.foo ne nous dit pas lequel des trois cas que nous avons. Cependant, on peut les combiner avec d' "foo" in obj de distinguer les cas.

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

Il est intéressant de noter que ces tests sont les mêmes pour null des entrées de trop

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

Je dirais que dans certains cas, il est plus logique (et plus claires) pour 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érent est le cas 2, le cas rare d'une entrée effective dans l'objet avec une valeur non définie.

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

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

Ce qui est plus clair lorsqu'il est écrit sans vérifier indéfini.

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

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