JavaScript hasOwnProperty vs typeof

Question

我在 Google 上搜索了很多，但找不到我要找的地方：

Benefit of using Object.hasOwnProperty vs testing if Property is undefined

jsperf speedtest

How to determine if Native JavaScript Object has a Property/Method?

.. 和很多其他网站，但这不是我要找的地方。我真正的问题是：

为什么hasOwnProperty 在他的超类（原型）中找不到方法？为什么有人甚至使用hasOwnProperty？它比typeof 慢得多，如果您使用继承，它就不起作用。

..第二个问题：

在this 问题中，Barney 回答您必须使用if ('property' in objectVar) 来检查属性是否存在，但没有解释原因。有人知道你为什么要使用这种结构吗？

var objA = function(){};

objA.prototype.alertMessage = function(){
        return 'Hello A';
};

var objB = function(){
    this.hello = function(){
        return 'hello';
    };
};

// Inheritance
objB.prototype  = Object.create(objA.prototype);
objB.prototype.constructor = objA;

var test = new objB();

if (test.hasOwnProperty("alertMessage")){
    console.log("hasOwnProperty: " + test.alertMessage());
}

if (typeof test.alertMessage === "function"){
    console.log("typeof: " + test.alertMessage());
}

if (test.hasOwnProperty("hello")){
    console.log("hasOwnProperty: " + test.hello());
}

if (typeof test.hello === "function"){
    console.log("typeof: " + test.hello());
}

Check out the jsFiddle

Answer 1

使用hasOwnProperty（在某些情况下必须使用）hasOwnProperty 及其行为的原因有很多：

• 顾名思义，hasOwnProperty 检查您测试的对象是否拥有具有给定名称的属性。如果它从另一个对象（它的原型）继承了一个方法/属性，那么该属性的所有者不是对象，而是它的原型。因此，该对象没有自己的名为 X 的属性
• typeof 大部分时间都可以工作，但对象可能看起来像这样：var o = {foo: undefined}。当然，在o.foo 上使用typeof 会产生"undefined"，但该对象确实拥有一个名为foo 的属性
• 使用if ('properyname' in object) 是一种解决方法，它结合了两全其美：在o = {foo: undefined}; 的情况下，它将评估为真，而无需查找hasOwnPropery 方法的开销（这是Object.prototype 的一个属性），或者一个带有上下文绑定的函数调用等等。它还会在原型链中找到属性

因此请考虑以下示例：

var o = {foo: undefined,
    toString: undefined};//overwrite inherited method
console.log(typeof o.foo);//undefined
console.log(typeof o.toString);//undefined
console.log(o.hasOwnProperty('toString'));//true
delete(o.toString);
console.log(typeof o.toString);//function
if ('valueOf' in o)
    console.log(o.valueOf === Object.prototype.valueOf);//true
if ('foo' in o)
    console.log(o.foo);//undefined

要注意的另一件重要事情是，您关于hasOwnProperty 在处理继承时不起作用的陈述只是简单的错误。你在 JS 中使用的每个对象都至少继承自一个原型。认识到、理解和尊重这一点很重要。如果您遍历一个对象，建议确保您实际上是在遍历属于该对象本身的属性。因此，这种情况并不少见：

for (p in obj)
{
    if (obj.hasOwnProperty(p))
        //process property
}

这是为了避免代码遍历原型链中的所有属性，这可能会破坏超级对象

if (!Object.prototype.hasProperty)
{//dirty check ;-P
    Object.prototype.hasProperty = (function(OP)
    {
        return function(name)
        {
            //typeof for speed: if value is not undefined, return true
            if (typeof this[name] !== 'undefined' || this.hasOwnProperty(name))
                return true;
            if (this === OP)//we've just checked the Object.prototype, found nothing, so return false
                return false;
            return Object.getPrototypeOf(this).hasProperty(name);//check prototype
        };
    }(Object.prototype));//OP is object prototype
}