Наследование в JS. Как вызвать метод родителя по цепочке наследования?

Question

[Владимир Б.]

Имеется своя реализация системы создания и наследования "классов".

Имеется возможность наследования в виде:

childClass.prototype = Object.create( parentClass.prototype );
	childClass.prototype.constructor = childClass;

// Копируем методы родителя с добавлением префикса, или в спец. список
// Прописываем сверху методы наследника

	childClass.prototype.parent = parentClass;
	childClass.prototype.parentMethodList = parentMethodList;
	childClass.prototype.childMethodList = childMethodList;
	childClass.prototype.inheritedMethodList = inheritedMethodList;

Реализовываю наследование: Class1 -> Class2 -> Class3.
При инициализации Class3 произвожу инициализацию Class2, а тот в свою очередь Class1.

...
constructor: function()
{
...
this.parent();
...
}

Но проблема в том, что в момент инициализации Class2, область видимости this остаётся на Class3, потому последующий вызов this.parent вызываем опять инициализацию Class2 вместо Class1 (выходит просто постоянная инициализация Class2 в рекурсии).
Пытался реализовать что-то вида:

childClass.prototype.parent = function( ) { new parentClass.apply( parentClass, arguments ); };

Но это всё не то.
Как выйти из данной ситуации?
Спасибо.

Листинг версии которую ковыряю: pastebin.com/iirPtLUJ

Answer 1

[Сергей Мельников]

Почему не воспользоваться готовой реализацией? Например, Backbone

function Class() {}

// Helper function to correctly set up the prototype chain for subclasses.
// Similar to `goog.inherits`, but uses a hash of prototype properties and
// class properties to be extended.
Class.extend = function(protoProps, staticProps) {
  var parent = this, child, prop;

  // The constructor function for the new subclass is either defined by you
  // (the "constructor" property in your `extend` definition), or defaulted
  // by us to simply call the parent constructor.
  if (protoProps && protoProps.hasOwnProperty('constructor')) {
    child = protoProps.constructor;
  } else {
    child = function() { return parent.apply(this, arguments); };
  }

  // Add static properties to the constructor function, if supplied.  
  for (prop in parent) child[prop] = parent[prop];
  for (prop in staticProps) child[prop] = staticProps[prop];

  // Set the prototype chain to inherit from `parent`, without calling
  // `parent` constructor function.
  var Surrogate = function() { this.constructor = child; };
  Surrogate.prototype = parent.prototype;
  child.prototype = new Surrogate;

  // Add prototype properties (instance properties) to the subclass,
  // if supplied.
  for (prop in protoProps) child.prototype[prop] = protoProps[prop];

  // Save parent prototype
  child.prototype.__super__ = parent.prototype;

  return child;
};

var Model = Class.extend({
  constructor: function() {
    console.log("Model:constructor()");
  }
});

var User = Model.extend({
  constructor: function() {
    this.__super__.constructor();
    console.log("User:constructor()");
  }
});

var SuperUser = User.extend({
  constructor: function() {
    this.__super__.constructor();
    console.log("SuperUser:constructor()");
  }
});

var supeUser = new SuperUser();

Comments

[Владимир Б.]

Спасибо, попробую.

[Владимир Б.]

Прошу прощения что долго не отвечал.
На самом деле данная реализация практически ничего не отличается от моей.
Но всё-же она натолкнула на интересную мысль, спасибо.

[6urkaaa]

ЛеНтЯй: что за мысль, если не секрет?

[Владимир Б.]

6urkaaa: Мысль в том что-бы "вызывающим" при обращении ко всем "родителям" кроме последнего - был сам "родитель", к последнему - "наследник".
Как-то так.

// Вызываем родительскую функцию по имени вызывающей функции
		childClass.prototype._parentCall_ = function( )
		{
			var callerObject = arguments.callee.caller;
			var callerFunction = arguments.callee.caller.name || '';
			var callerArguments = ( arguments.length > 0 ? arguments : arguments.callee.caller.arguments );

			if( callerFunction !== '' && this._parent_[ callerFunction ] !== undefined )
			{
				var caller = ( callerObject.prototype._className_ === this._parent_._className_ ) ? this._parent_ : this;
				return caller._parent_[ callerFunction ].apply( caller, callerArguments );
			}
			else if( callerFunction === '' )
			{
				console.warn( this._className_ + ': У вызывающей функции нет имени!' );
			}
			else
			{
				console.warn( this._className_ + ': Функции "' + callerFunction + '" не существует!' );
			}
		};