John Resig ist Javascript Vererbung snippet veraltet?

Heißt das, ich sollte das nicht verwenden von John Resig ' s code?

Korrigieren, nicht, wenn Sie mit ES5 im strict-Modus. Jedoch, es kann leicht angepasst werden:

/* Simple JavaScript Inheritance for ES 5.1
 * based on http://ejohn.org/blog/simple-javascript-inheritance/
 *  (inspired by base2 and Prototype)
 * MIT Licensed.
 */
(function(global) {
  "use strict";
  var fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

  //The base Class implementation (does nothing)
  function BaseClass(){}

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

    //Set up the prototype to inherit from the base class
    //(but without running the init constructor)
    var proto = Object.create(_super);

    //Copy the properties over onto the new prototype
    for (var name in props) {
      //Check if we're overwriting an existing function
      proto[name] = typeof props[name] === "function" && 
        typeof _super[name] == "function" && fnTest.test(props[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, props[name])
        : props[name];
    }

    //The new constructor
    var newClass = typeof proto.init === "function"
      ? proto.hasOwnProperty("init")
        ? proto.init //All construction is actually done in the init method
        : function SubClass(){ _super.init.apply(this, arguments); }
      : function EmptyClass(){};

    //Populate our constructed prototype object
    newClass.prototype = proto;

    //Enforce the constructor to be what we expect
    proto.constructor = newClass;

    //And make this class extendable
    newClass.extend = BaseClass.extend;

    return newClass;
  };

  //export
  global.Class = BaseClass;
})(this);

Dies ist etwas, was ich kam mit Vererbung mit Verkettung sowie die _super zu arbeiten.

/**
 * JavaScript simple inheritance
 * by Alejandro Gonzalez Sole (base on John Resig's simple inheritance script)
 * MIT Licensed.
 **/
(function (){
    var initializing = false,
      fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.* /;

    function Class(){};

    function inheritClass(superClass){
      var self = this;
      function Class(){
        if (!initializing && typeof this._constructor === 'function')
          this._constructor.apply(this, arguments);
      }

      Class.prototype = superClass.prototype;
      Class.prototype._constructor = superClass;
      Class.prototype.constructor = Class;
      Class.extend = extendClass;
      //currenlty if you inhert multiple classes it breaks
      Class.inherit = inheritClass;
      return Class;
    };

    function extendClass(prop) {
      var self = this;
      var _super = self.prototype;

      function Class(){
        if (!initializing && typeof this._constructor === 'function')
          this._constructor.apply(this, arguments);
      }

      initializing = true;
      var prototype = new self();
      initializing = false;

      for (var name in prop) {
        prototype[name] = typeof prop[name] == "function" &&
          typeof _super[name] == "function" && fnTest.test(prop[name]) ?
          (function(name, fn){
            return function() {
              var tmp = this._super;
              this._super = _super[name];
              var ret = fn.apply(this, arguments);
              this._super = tmp;
              return ret;
            };
          })(name, prop[name]) : prop[name];
      }

      Class.prototype = prototype;
      Class.prototype.constructor = Class;
      Class.extend = extendClass;
      Class.inherit = inheritClass;

      return Class;
    };

    Class.extend = extendClass;
    Class.inherit = inheritClass;

})();


//EXAMPLE

function Person(){
  this.name = "No name";
  console.log("PERSON CLASS CONSTRUCTOR")
}
Person.prototype.myMethod = function (t){
  console.log("MY PERSON", t, this.name);
  return -1;
}

var TestPerson = Class.inherit(Person).extend({
    _constructor: function(){
      this._super();
      this.name = "JOhn";
      console.log("TEST PERSON CONSTRUCTOR");
    },
    myMethod: function (t){
      console.log("TEST PERSON", t, this.name);
      return this._super(t)
    }
});


var test = new TestPerson();

console.log(test.myMethod("BA"));

Habe ich es getestet auf meinem pixi-wrapper https://github.com/guatedude2/pixijs-cli bisher war es sehr gut funktioniert für mich.

Das einzige Problem, das ich gestoßen bin bei diesem Ansatz ist, dass man nur einmal Erben. Wenn Sie Erben wieder überschreibt er die vorherigen Vererbung.