Javascript類屬性表現爲共享變量

Question

我有以下聲明可以輕鬆地在Javascript中創建類。該班是從這篇文章：http://ejohn.org/blog/simple-javascript-inheritance/

的jsfiddle：http://jsfiddle.net/xUCQp/

的問題是，它似乎像該對象的選擇似乎是通過對象共享，但我需要他們的實例變量。代碼有什麼問題？

代碼：

/* Simple JavaScript Inheritance 
* By John Resig http://ejohn.org/ 
* MIT Licensed. 
*/ 
// Inspired by base2 and Prototype 
(function() { 
    var initializing = false, fnTest = /xyz/.test(function() { 
     xyz; 
    }) ? /\b_super\b/ : /.*/; 

    // The base Class implementation (does nothing) 
    this.NClass = function() { 
    }; 

    // Create a new Class that inherits from this class 
    NClass.extend = function(prop) { 
     var _super = this.prototype; 

     // Instantiate a base class (but only create the instance, 
     // don't run the init constructor) 
     initializing = true; 
     var prototype = new this(); 
     initializing = false; 

     // Copy the properties over onto the new prototype 
     for (var name in prop) { 
      // Check if we're overwriting an existing function 
      prototype[name] = typeof prop[name] == "function" && 
        typeof _super[name] == "function" && fnTest.test(prop[name]) ? 
        (function(name, fn) { 
         return function() { 
          var tmp = this._super; 

          // Add a new ._super() method that is the same method 
          // but on the super-class 
          this._super = _super[name]; 

          // The method only need to be bound temporarily, so we 
          // remove it when we're done executing 
          var ret = fn.apply(this, arguments); 
          this._super = tmp; 

          return ret; 
         }; 
        })(name, prop[name]) : 
        prop[name]; 
     } 

     // The dummy class constructor 
     function NClass() { 
      var $this = this; 
      // All construction is actually done in the init method 
      if (!initializing && this.init) 
       this.init.apply(this, arguments); 
     } 

     // Populate our constructed prototype object 
     NClass.prototype = prototype; 

     // Enforce the constructor to be what we expect 
     NClass.prototype.constructor = NClass; 

     // And make this class extendable 
     NClass.extend = arguments.callee; 

     return NClass; 
    }; 
})(); 

(function (scope, undefined) { 
scope.ssTypeBase = NClass.extend({ 
     options: { 
      test: 0 
     }, 
    init: function(test){ 
     this.options.test = test; 
    } 
}); 

    var a = new scope.ssTypeBase(1); 
    var b = new scope.ssTypeBase(2); 
    console.log(a.options.test,b.options.test); 
})(window); 

Answer 1

原型屬性的對象之間總是被分擔。所以在這種情況下，如果你想選項對象是實例變量比設置選項對象內部構造這樣的

(function (scope, undefined) { 
    scope.ssTypeBase = NClass.extend({ 
     sharedOptionsObject: { 
      test: 0 
     }, 
     init: function(test){ 
      // create options object here, it will create seperate options object for each instance 

      this.options = { 
       test: 0 
      } 
      this.options.test = test; 
     } 
    }); 
});