Question

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

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

为什么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会检查您测试 的对象是否拥有 具有给定名称的属性。如果它从另一个对象（其原型）继承了一个方法/属性，那么该属性的所有者不是对象，而是它的原型。因此，对象没有自己的属性X
typeof大部分时间都可以使用，但对象可能如下所示：var o = {foo: undefined}。当然，在typeof上使用o.foo会产生"undefined"，但该对象拥有一个名为foo的属性
使用if ('properyname' in object)是一种解决方法，它结合了两者的优点：在o = {foo: undefined};的情况下，将评估为true，而无需查找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
}

JavaScript hasOwnProperty vs typeof

1 个答案: