TW Blog :: Archives for October 2004

Super Simulation in Javascript OOP

Relates to DOM Scripting

Writing some Javascript the other day I found myself wanting to override a method of an object's prototypical object while still having access to the inherited method. That is, in class based terminology, I wanted to be able to invoke the overriden method of the superclass. In Java this is achieved with the keyword super which provides a reference to the current object as an instance of its superclass. However, as a prototype-based language, Javascript does not provide such a reference. Kevin Lindsey demonstrates the recursive dilemma and suggests an idiom for simulating constructor chaining by utilising the ECMA compliant call method. While this could serve my purpose, I decided to look for a way to create a single reference to access overriden member variables and methods (just like super).

Here is one possible solution:

Object.prototype.parent = function(type) {
  var p = new Object();
  for (x in type.prototype) {
    if (x != "parent") {
      p[x.toString()] = this[x.toString()];          
    }
  }   
  return p;  
}

function BoxContainer(param) {
    
  Container.call(this, param);
    
  var parent = this.parent(BoxContainer);
  
  this.service = function() {
    if (this.service.arguments.length == 0) {    
      return parent.service();    
    }
    else {
      // .. do some stuff ..
      return stuff;  
    }
  }  
}
BoxContainer.prototype = new Container;

The prototype object, Container, is that used by Douglas Crockford in his article Private Members in Javascript.

A new method, parent, is added to the prototype property of the Object object. This method allows an temporary object to be filled with the public access variables and methods of a prototype before they are overriden. So, the constructor function, BoxContainer, invokes this method passing its prototypical object. The method returns a new object reference filled with all the properties and methods of the prototypical object, and this is assigned to a private variable, parent. Then a closure allows the inner function service to maintain access to parent after the constructor function BoxContainer has returned. (NB while super may have been an elegant choice for the identifier, it is a reserved word, so I choose to use parent - not to be confused with DOM!)

Posted on Friday, Oct 08, 2004 at 03:44:50.