Undefined, typeof undefined, hasOwnProperty

Si votre vérification standard des objets qui sont le résultat de l'analyse d'une chaîne JSON, .hasOwnProperty n'a pas d'avantage évident. Sauf, bien sûr, si vous-même ou certains lib vous utilisez a été déconner avec le Object.prototype.

En général, undefined en tant que telle peut être redéfini, mais je n'ai pas rencontré moi-même - je ne crois pas que je vais jamais le faire. Il est toutefois impossible (à ma connaissance) à gâcher les valeurs de retour de typeof. À cet égard, le dernier est le plus sûr moyen d'aller. Je crois que certains anciens navigateurs ne fonctionnent pas bien avec le undefined mot-clé, trop.

À la reprise de l': pas besoin d'aller et de remplacer tous les typeof vérifier. Sur une note personnelle: je crois qu'il est de bonne pratique d'obtenir dans l'habitude de l'utiliser .hasOwnPropertycependant. Donc je proposerais que, dans le cas d'une propriété pourrait exister, mais être indéfini, .hasOwnPorperty est le pari le plus sûr.

---

En réponse à votre commentaire: oui, typeof adaptée à vos besoins ~95% du temps. .hasOwnProperty travaillera 99% des fois. Toutefois, comme le nom l'indique: les propriétés de plus haut dans la chaîne d'héritage ne sera pas vérifié, considérons l'exemple suivant:

Child.prototype = new Parent();
Child.prototype.constructor=Child;//otherwise instance.constructor points to parent

function Parent()
{
    this.foo = 'bar';
}

function Child()
{
    this.bar = 'baz';
}

var kiddo = new Child();
if (kiddo.hasOwnProperty('foo'))
{
    console.log('This code won\'t be executed');
}
if (typeof kiddo.foo !== 'undefined')
{
    console.log('This will, foo is a property of Parent');
}

Donc, si vous voulez vérifier si un objet possède une propriété, hasOwnProperty est ce que vous avez besoin. Surtout si vous allez pour changer la valeur de la propriété (si c'est un prototype de la propriété, toutes les instances peuvent être modifiés).
Si vous voulez savoir si un bien a une valeur (autres que undefined), indépendamment de l'endroit où il est situé dans la chaîne d'héritage, vous aurez besoin typeof. J'ai une fonction récursive quelque part pour déterminer où la propriété peut être trouvée dans l'héritage de la chaîne. Une fois que je l'ai trouvé, je vais le poster ici, trop.

Mise à jour:

Comme promis, la fonction pour trouver une propriété dans une chaîne d'héritage. Ce n'est pas la fonction que j'ai utilisé pendant un certain temps, j'ai donc monté un projet de travail. Il n'est pas parfait, mais il pourrait bien vous aider sur votre chemin:

function locateProperty(obj,prop,recursion)
{
    recursion = recursion || false;
    var current = obj.constructor.toString().match(/function\s+(.+?)\s*\(/m)[1];
    if (!(obj.hasOwnProperty(prop)))
    {
        if (current === 'Function' || recursion === current)
        {
            return false;
        }
        return locateProperty(new window[current](),prop,current);
    }
    return current;
}
//using the object kiddo
locateProperty(kiddo,'foo');//returns 'Parent'
locateProperty(kiddo,'bar');//returns 'Parent', too

Pour éviter ce dernier problème, vous pouvez soit remplacer la dernière return current; déclaration avec return obj;. Ou, mieux encore, ajoutez la ligne suivante à l'extrait ci-dessus:

Child.prototype.constructor=Child;

J'ai oublié que dans la première édition...