1

我不知道更好的标题，所以解释一下，假设你有一个“构造函数”

  • 实例化一个对象并设置一些属性
    • 在 Instatiation 的过程中创建了另一个 Object
    • 这个 Objects 原型应该覆盖从第一个 Object 到他的 Children 的一些属性

因此，当第一个 Objects 属性num更改时，其他 Objects 原型属性num 也应该更改

这当然会在以下情况下num工作

  • 包裹在一个对象中
  • 非原始对象的属性/元素

但如果num是数字或字符串

如果将在第一个对象中被覆盖，则原型的属性不会改变，num因为原始变量作为值而不是通过引用传递，或者如果属性是对象并且将被新对象覆盖

所以我的问题是，是否有任何“简洁”的方法可以让一个对象从另一个对象继承属性的原始值，并让它们共享一个引用？

这是一些示例代码，您可以跳过第一个，这里是为了代码的完整性

/* Inheritance Helper*/

var base = (function baseConstructor() {

  var obj = {
    create:function instantiation() {
        if(this != base) {
        var instance = Object.create(this.pub);
         this.init.apply(instance,arguments);
         this.instances.push(instance);
        return instance;
        } else {
          throw new Error("You can't create instances of base");
        }
    },
    inherit:function inheritation() {
      var sub = Object.create(this);
      sub.pub = Object.create(this.pub);
      sub.sup = this;
      return sub;
    },
    initclosure:function initiation() {},
    instances: [],
    pub: {}
    
  };
  
  
  
  Object.defineProperty(obj,"init",{
   set:function (fn) {
     if (typeof fn != "function")
       throw new Error("init has to be a function");
     if (!this.hasOwnProperty("initclosure"))      
       this.initclosure = fn;
    },
    get:function () {
        var that = this;
        //console.log(that)
            return function() {
              if(that.pub.isPrototypeOf(this)) //!(obj.isPrototypeOf(this) || that == this))
                that.initclosure.apply(this,arguments);
              else
                throw new Error("init can't be called directly"); 
             };
    }    
     
  });
  
  
  Object.defineProperty(obj,"create",{configurable:false,writable:false});
    Object.defineProperty(obj,"inherit",{configurable:false,writable:false});
  return obj;
})();

/*Helpers*/
function merge (obj) {
 if(arguments.length < 2)
   throw new Error({msg:"At least 2 parameters needed"});
  for ( var i = 1, ilen = arguments.length;i < ilen; i++)
   for (var k in arguments[i])
     obj[k] = arguments[i][k];
}

/*Helpers for workarounds*/
function tieProp (prop,obj) {
  if(arguments.length < 3)
    throw new Error({msg:"At least 2 Objects are needed"});
  var ref = obj[prop];
  
  for ( var i = 1,ilen = arguments.length;i<ilen;i++)
      Object.defineProperty(arguments[i],prop,{
      set: function (val) {
        ref = val;
      },
      get: function () {
        return ref;
      }
    });

}

所以，这是创建对象的部分

/*Example Code*/

var Series = base.inherit();
Series.init = function (specs) {
  var _Series = this;
      specs = specs ||{};

  this.seasons = [];
  
  var Season = Series.inherit();
  Season.init = function(specs) {
    var _Season = this;
        specs = specs || {};
    _Series.seasons.push(this);
    
    merge(this,specs);  
   
        
        
  };
  
  merge(this,specs);
  Season.pub.score = this.score; // First way
  Season.pub.stats = this.stats; // Second Way
  tieProp("scoreTied",this,Season.pub); //Third Way
  Season.pub.scoreSetter = this.scoreSetter; // Second Way
  
    this.updateScore = function (score) { // Forth Way
      this.scoreSetter = score;
      Season.pub.scoreSetter = score;
  };
  tieProp("someObj",this,Season.pub); //Obj Example
  
  this.addSeason = function (specs)  {
    Season.create(specs);
  };
  

};
Series.pub.toString = function () {
 return this.title + " has  a score of " + this.scoreTied ;
};


var Futurama = Series.create({
  title:"Futurama",
  score:1, // 1.
  scoreTied:2, // 2.
  stats:{ //3.
    score:3
  },
  scoreSetter:4,
  someObj:{a:"b"}
});
Futurama.addSeason();

并在我们更改属性之前记录控制台输出

console.log("BeforeChange",Futurama.score + " - " + Futurama.seasons[0].score); //"1 - 1"
console.log(Futurama.scoreTied + " - " + Futurama.seasons[0].scoreTied); // "2 - 2"
console.log(Futurama.stats.score +  " - " + Futurama.seasons[0].stats.score); // "3 - 3"
console.log(Futurama.scoreSetter +  " - " + Futurama.seasons[0].scoreSetter); //"4 - 4"
console.log(JSON.stringify(Futurama.someObj) + " - " + JSON.stringify(Futurama.seasons[0].someObj));  //"{"a":"b"} - {"a":"b"}"

然后改变分数属性Futurama

Futurama.score = 2; //TFirst way // This will fail
Futurama.scoreTied = 3; //Second way
Futurama.stats.score = 4; // Third way 
Futurama.updateScore(5); // Forth Way
Futurama.someObj = {b:"a"}; // Object replacement

并记录它们

console.log("After Change",Futurama.score + " - " + Futurama.seasons[0].score); // 2 - 1
console.log(Futurama.scoreTied + " - " + Futurama.seasons[0].scoreTied); // 3 - 3
console.log(Futurama.stats.score +  " - " + Futurama.seasons[0].stats.score); //4 -4 
  console.log(Futurama.scoreSetter +  " - " + Futurama.seasons[0].scoreSetter); //5 - 5
console.log(JSON.stringify(Futurama.someObj) + " - " + JSON.stringify(Futurama.seasons[0].someObj)) ; //"{"b":"a"} - {"b":"a"}"

所以，这在任何使用时都是可能的

  • Object.defineProperty 为属性提供 getter 和 setter

像 function tieProp (prop,obj) {...

但我不知道在这种情况下使用 Object.defineProperty 是否合适，我真的必须设置属性描述符以让某些属性共享一个对原始值的引用吗？

  • 将所有原始值包装在一个对象中，该对象将作为引用传递并更改此对象属性

像Season.pub.stats = this.stats; // Second Way

这没关系，但我对此不太满意，因为我必须将属性移动到另一个属性中，这会剥夺一些命名自由，在这个例子中，我想score作为 Futurama 的分数进入Futurama.score而不是进入Futurama.stats.score

*为属性编写设置器，它只是设置对象的两个值

*喜欢 this.updateScore = function (score) { // Forth Way*

但我宁愿远离这个，因为我必须向对象添加方法

我不知道我是否根本不应该做这样的事情，或者我只是错过了一种非常简单的方法？

任何正确方向的建议或指示将不胜感激

并提前感谢您的回答和耐心阅读本文

这是一个可以摆弄的JSBin

4

1 回答 1

0

使用命名函数作为属性值来共享原子元素的实例：

foo = {"1":1}
bar = {"1": function baz() { return foo["1"] } }

foo["1"] = 2;
foo["1"] === bar["1"]();

参考

于 2013-01-08T22:43:31.170 回答