hasOwnProperty 在对照父对象属性进行检查时返回 true

My JavaScript code：

console.clear();
function BaseClass(nname) {
  var name = nname;
  this.bc_PublicProperty = "DefaultValue_BaseClass";
  this.bc_getName = function GetName() {
    return name;
  };
  this.bc_setName = function SetName(nname) {
    name = nname;
  };
}
function SubClass(nname) {
  BaseClass.call(this, nname);
  this.sc_PublicProperty = "DefaultValue_SubClass";
  this.sc_getName = function GetName() {
    return name;
  };
  this.sc_setName = function SetName(nname) {
    name = nname;
  };
}
SubClass.prototype = Object.create(BaseClass.prototype);
SubClass.prototype.constructor = SubClass;
var bc = new BaseClass("Anton");
var sc = new SubClass("Bernd");
console.log("hasOwnProperty check on subclass object 'sc' returns true for Method 'bc_getName'");
for (var pro in sc) {
  console.log("Is " + pro + " own property of subclass:  --> " + Object.hasOwnProperty.call(sc, pro));
}

我有两个对象（BaseClass 和 SubClass）。一个使用构造函数模式从另一个继承，如 MDN 中所述。

现在，当我遍历子类对象的所有属性时，它们都为 hasOwnProperty 返回 true，即使对于父方法/属性，构造函数除外。

这是否意味着，它在使用构造函数模式时会中断？

当我将公共属性和方法放在构造函数中时，无论是在 BaseClass 还是 SubClass 中，它们都将始终"标记为"自己的属性/方法。当我将它们附加到相应的原型时，hasOwnProperty 将为它们输出"false"。

无论您将公共方法/属性放入原型还是构造函数本身，它们都可以在子类（--> SubClass2、--> SubClass3）中使用。

我现在能想到的唯一一件事，为什么你应该将它们附加到原型对象，是因为效率原因，正如这里解释的那样，"定义类方法"部分。为了不为每个构造实例添加闭包。

值

类型应该在原型上声明，但不能声明其初始值依赖于构造函数的参数或构造时的某些其他状态的实例变量。您可以重写这两个属性/函数，而不考虑它们的声明位置。

此外，在原型上设置 getter 和 setter，

例如设置或获取私有变量，是没有意义的，因为私有变量必须是公共的，以便附加到原型的 getter 和 setter 可以访问。

因此，使用吸气剂和二传手是没有意义的。您可以直接访问公共变量。

我现在必须稍微调整一下我的问题：

我什么时候需要hasOwnProperty，如果实际上应该在原型上声明公共道具/函数，那么原型又会输出Object.hasOwnProperty（obj，"prop/func"） --> false。给我一个用例，如果有意义，使用hasOwnProperty。

console.clear();
var l = function(v) {
  console.log(v);
};
function BaseClass(nname) {
  this.bc_nameProp = nname;
  this.bc_ownFunc = function() {
    l("bc_ownFunc of BaseClass called");
  };
  this.bc_getName = function GetName() {
    return this.bc_nameProp;
  };
}
BaseClass.prototype.bc_getName = function GetName() {
  return this.bc_nameProp;
};
BaseClass.prototype.bc_PublicProperty = "DefaultValue_BaseClass";
BaseClass.prototype.bc_setName = function SetName(nname) {
  bc_nameProp = nname;
};
function SubClass(nname) {
  BaseClass.call(this, nname);
  this.sc_setName = function SetName(nname) {
    bc_nameProp = nname;
  };
  this.bc_getName = function GetName() {
    return "xyz";
  };
}
SubClass.prototype = Object.create(BaseClass.prototype);
SubClass.prototype.constructor = SubClass;
SubClass.prototype.sc_getName = function GetName() {
  return this.bc_nameProp;
};
SubClass.prototype.sc_PublicProperty = "DefaultValue_SubClass";
var bc = new BaseClass("Anton");
var sc = new SubClass("Bernd");
l("-----  iterating over BaseClass properties  ------");
l("");
for (var pro in bc) {
  l("Is " + pro + " own property of BaseClass:  --> " + Object.hasOwnProperty.call(bc, pro));
}
l("");
l("-----  iterating over SubClass properties  ------");
l("");
for (var p in sc) {
  l("Is " + p + " own property of subclass:  --> " + Object.hasOwnProperty.call(sc, p));
}
l(bc.bc_getName());
l(sc.bc_getName());
l(sc.sc_getName());

---

溶液

当我问这个问题时，我认为，当在JavaScript中使用经典继承时，我可以使用hasOwnProperty来区分我的子类的哪些属性/函数直接属于它。这是不可能的，因为父原型的所有属性/函数都复制到子类的原型中：

SubClass.prototype = Object.create(BaseClass.prototype);

当使用hasOwnProperty时，附加到原型的所有属性/函数都返回"false"。

如果你在 BaseClass 和 SubClass 的构造函数中声明了公共属性/函数，那么当为子类上的这些属性调用 hasOwnProperty 时，所有这些属性都返回"true"。

使用以下语句将这些复制到子类：

BaseClass.call(this, nname);

因此，在迭代 SubClass 类型的 obj 的所有属性时使用 hasOwnProperty，将为在原型级别声明的所有属性/函数输出 false，对于在构造函数级别声明的所有属性/函数输出 true。

现在，我明白为什么在这个用例中使用hasOwnProperty是没有意义的。

    var A = function() {};
    A.prototype = {
       doStuff: function() {}
    };

var A = function() {};
var instance = new A();
instance.text = "Hello, World!";
// or...
var A = function() {
    this.text = "Hello, World!";
};
var instance = new A();

function X(uri, options) {
   if(typeof options != "undefined") {
       // For example, we set a default value if options has no
       // mimeType property...
       options.mimeType = options.hasOwnProperty("mimeType") ? options.mimeType : "application/json";
   }
}

SubClass.prototype = Object.create(BaseClass.prototype);