Editing goog.inherit Vs. simple inherit

This edit will create a new revision.

Your details (optional)

Name

Email (won’t be displayed; might be used for Gravatar)

URL

Test case details

Title *

Published (uncheck if you want to fiddle around before making the page public)

Description (in case you feel further explanation is needed)(Markdown syntax is allowed)

Are you a spammer? (just answer the question)

Preparation code

Preparation code HTML (this will be inserted in the <body> of a valid HTML5 document in standards mode) (useful when testing DOM operations or including libraries)

Include JavaScript libraries as follows: <script src="//cdn.ext/library.js"></script>

Define setup for all tests (variables, functions, arrays or other objects that will be used in the tests) (runs before each clocked test loop, outside of the timed code region) (e.g. define local test variables, reset global variables, clear canvas, etc.) (see FAQ)

var goog = {};
goog.inherits = function(childCtor, parentCtor) { /** @constructor */

// If we did not find the caller in the prototype chain,
  // then one of two things happened:
  // 1) The caller is an instance method.
  // 2) This method was not called by the right caller.
  if (me[opt_methodName] === caller) {
    return me.constructor.prototype[opt_methodName].apply(me, args);
  } else {
    throw Error('goog.base called from a method of one name ' + 'to a method of a different name');
  }
};

var fnTest = /xyz/.test(function() {
  xyz;
}) ? /\b_super\b/ : /.*/;

Class = function() {};
Class.extend = function extend(prop) {
  var _super = this.prototype;

function Child() {
    if (this.init) this.init.apply(this, arguments);
  }
  Child.prototype = Object.create(this.prototype);
  Child.prototype.constructor = Child;
  Child.extend = extend;

for (var name in prop) {
    // Check if we're overwriting an existing function
    if (typeof prop[name] == "function" && typeof _super[name] == "function" && /\b_super\b/.test(prop[name])) {
      Child.prototype[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]);
    } else {
      Child.prototype[name] = prop[name];
    }
  }
  return Child;
}

ClassJR = function() {};

// Create a new Class that inherits from this class
ClassJR.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 Class() {
    // All construction is actually done in the init method
    if (!initializing && this.init) this.init.apply(this, arguments);
  }

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

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

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

return Class;
};

ClassSG = function() {};

// Create a new Class that inherits from this class
ClassSG.extend = function(prop) {

var _super = this.prototype;

// Instantiate a base class (but only create the instance,
  // don't run the init constructor)
  var Surrogate = function() {
      this.constructor = {};
      };

Surrogate.prototype = this.prototype;

prototype = new Surrogate;

// 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 Class() {

// All construction is actually done in the init method
    if (this.init)

this.init.apply(this, arguments);

}

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

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

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

return Class;

};

BBClass = function(ctor) {
  ctor.prototype = Object.create({}, {
    constructor: {
      value: ctor,
      enumerable: false
    }
  });
  ctor.extend = function(parent) {
    function ChildBB() {
      parent.prototype.constructor.apply(this, arguments);
      ctor.apply(this, arguments);
    };
    ChildBB.prototype = (typeof Object.create !== 'function') ? (function(parent) {
      function F() {};
      F.prototype = parent.prototype;
      var prototype = new F();
      prototype.constructor = ChildBB;
      return prototype;
    })(parent) : Object.create(parent.prototype, {
      constructor: {
        value: ChildBB,
        enumerable: false
      }
    });
    return ChildBB;
  }
  return ctor;
};

fpAprototype = {
  foo: function() {
    return "foo";
  },
  hello: function() {
    return "hello";
  },
  foobar: function() {
    return "foobar";
  }
};

function createFPA() {
  var instance = Object.create(fpAprototype);
  //this is constructor
  instance.a = 'a';
  instance.b = 'b';
  instance.c = this.a + this.b;
  return instance;
}

var fpBprototype = fpAprototype;
fpBprototype.bar = function() {
  return "bar";
};
fpBprototype.foobar = function() {
  return fpAprototype.prototype.foobar.call(this);
};

function createFPB() {
  return Object.create(fpBprototype);

}

Define teardown for all tests (runs after each clocked test loop, outside of the timed code region) (see FAQ)

Editing goog.inherit Vs. simple inherit

Your details (optional)

Test case details

Preparation code

Code snippets to compare

Test 1

Test 2

Test 3

Test 4

Test 5

Test 6

Test 7

Test 8

Test 9

Test 10

Test 11

Test 12

Test 13

Test 14

Test 15