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;

Title

Async (check if this is an asynchronous test)

Code

var ESGA = new extendSGA();
var ESGB = new extendSGB();