在javascript中扩展继承的原型对象

Plunker-（代码也在本文末尾）

我有一个原型函数（通用）和另一个扩展这个原型的函数（专用）。在通用原型中，我有一个数据对象。我希望特定对象使用此数据对象作为其自己的原型数据对象数据的基础，并向此数据对象添加键，而不是创建新的数据对象（我认为它正在这样做）

普朗克应该说明我的意思

有人能告诉我，我缺少什么样的原型魔法来实现特定的功能吗？我还需要检查数据祖先的属性，而不是（看起来是这样的）在自己的原型中创建一个新的数据对象

<script>
  function genericDataObject ( dataObject ) {
    if( !dataObject ) {
      this.data = {};
    } else {
      this.loadDataObject(dataObject);
    }
  }

  genericDataObject.prototype = {
    //want all data objects to have the alwayshere property
    data: {alwayshere: null},
    loadDataObject:  function (dataObject) {
      //if our dataObject has a key that is set to null in data then replace null with that key's value
      for (var key in dataObject) {
        if( this.data[key] === null) {
          this.data[key] = dataObject[key];
        }
      }
    }
  }

  function specificDataObject ( dataObject ) {
    genericDataObject.call(this, dataObject );
  }
  specificDataObject.prototype = new genericDataObject();
  //add specific properties, shouldn't data be instantiated here with alwayshere as we've called new genericDataObject()????
  specificDataObject.prototype.data.specificData1 = null;
  specificDataObject.prototype.data.specificData2 = null;  

  var genericObject = new genericDataObject( { alwayshere: "here it is"}  );
  var specificObject = new specificDataObject( {alwayshere: "where is it?", specificData1: "this works"});

  document.write( genericObject.data.alwayshere + "<br />"); //"here it is"
  document.write( specificObject.data.alwayshere + "<br />" );// undefined
  document.write( specificObject.data.specificData1);// "this works"

</script>

函数genericDataObject（dataObject）{
如果（！dataObject）{
this.data={}；
}否则{
this.loadDataObject（dataObject）；
}
}
genericDataObject.prototype={
//希望所有数据对象都具有alwayshere属性
数据：{alwayshere:null}，
loadDataObject:函数（dataObject）{
//如果我们的数据对象有一个在数据中设置为null的键，那么用该键的值替换null
for（数据对象中的var键）{
if（此.data[key]==null）{
this.data[key]=数据对象[key]；
}
}
}
}
函数specificDataObject（dataObject）{
调用（this，dataObject）；
}
specificDataObject.prototype=新的genericDataObject（）；
//添加特定属性，数据不应该在这里用alwayshere实例化吗？我们称之为新的genericDataObject（）？？？？
specificDataObject.prototype.data.specificData1=null；
specificDataObject.prototype.data.specificData2=null；
var generiobject=新的genericDataObject（{alwayshere:“它在这里”}）；
var specificObject=new specificDataObject（{alwayshere:“它在哪里？”，specificData1:“它工作”}）；
document.write（generiobject.data.alwayshere+“
”）//“在这儿”
document.write（specifiobject.data.alwayshere+“
”）；//未定义
document.write（specifiobject.data.specificData1）；//“这很有效”

您需要为每个实例创建一个新的

数据

对象，否则所有实例将共享同一个对象（从原型继承给所有实例），对该对象的修改将影响所有实例

对象之间的关系非常混乱：

generiobject:{}//empty！！！
-从genericDataObject.prototype继承.data（和其他属性）
specificObject:{}//empty！！！
-从specificDataObject.prototype继承.data（和其他属性）
genericDataObject.prototype:{data:…，loadDataObject:…}
-继承自Object.prototype
genericDataObject.prototype.data:{alwayshere:“在这里”}
-继承自Object.prototype
-在原型文本中创建为{alwayshere:null}
-在genericObject.loadDataObject（…）/！！中指定了“此处为”！！！
specificDataObject.prototype:{data:…}
-从genericDataObject.prototype继承
-由`新的genericDataObject（）创建`
specificDataObject.prototype.data:{specificData1:“这很有效”，specificData2:null}
-继承自Object.prototype/！！！
-在genericDataObject构造函数中创建为{}
-显式分配specificData1:null，specificData2:null
-在specificObject.loadDataObject（…）中*没有*分配alwayshere：“它在哪里？”
因为.alwayshere不是“null”-该属性不存在/！！！
-是否在specificObject.loadDataObject（…）/！！中分配了specificData1:“这有效”！！！

如您所见，只有两个

data

对象以某种方式累积了所有属性。其中一个不从另一个继承-只有两个

.prototype

对象具有原型关系。这不是你想要的

相反，您应该：

function genericDataObject ( dataObject ) {
  this.data = Object.create(this.data);
  if (dataObject) {
    this.loadDataObject(dataObject);
  }
}

genericDataObject.prototype.data = {alwayshere: null};
genericDataObject.prototype.loadDataObject = function (dataObject) {
  // *only* if our dataObject has a key that is set to null in data then replace null with that key's value
  for (var key in dataObject) {
    if( this.data[key] === null) {
      this.data[key] = dataObject[key];
    }
  }
};

function specificDataObject(dataObject) {
  genericDataObject.call(this, dataObject);
}
specificDataObject.prototype = Object.create(genericDataObject.prototype);
specificDataObject.prototype.data = Object.create(genericDataObject.prototype.data);
specificDataObject.prototype.data.specificData1 = null;
specificDataObject.prototype.data.specificData2 = null;

---

所以为了安全地使用原型实例变量，应该将它们创建为新对象？（object.create）。更改这一行似乎解决了我的问题，原型链是否不正确，因为我使用了specificDataObject.prototype的新限定符？是的，从共享对象继承的新对象。对于

specificDataObject.prototype

：原型链是正确的，但是。