my humble addition allows parent methods to be called without using “apply”.

if B extends A as in Mr. Fuecks examples, and “obj” is an instance of A, and “category” a virtual function, class A’s version can be invoked on obj as “obj.A_category()” similar to the c++ syntax “obj->A::category()”

Your code would look like this.
It’s simple and good enough for my needs.
As said, I’m happy that it doesn’t need copyPrototype and is possible to call the base class method which has been overridden.

function Animal(type) 
      { 
            alert('Base class constructor'); 

	    this.species = type; 
	    
	     //this method doesn’t need to be called from the derived class!
             this.SayHello = SayHello;
             
             function SayHello()
             {
                 alert ("Base class SayHello() '"+this.species+"'");
             } 
	
	     
	     //must be overridden  in the derived class
     	     Animal.prototype.Category = function()
	     { 
	            alert('Base class Category() ' +this.species); 
	     }
   	 
 
	}
	
         
	  
		 
	function Dog(type) 
	{ 
            alert('Derived class constructor'); 

	    // Call the base class constructor 
            Animal.call (this,type); 
   
            //override method
  	    Dog.prototype.Category = function() 
	    { 
	        //call the base class version !
	        Animal.prototype.Category.call(this); 
	        alert("Derived class Category() " +this.species); 
	    }
     
    }
   

var d = new Dog('dog'); 
   d.SayHello();
   d.Category();

The single inheritance example below doesn’t need copyPrototype.
It works fine.

And is possible to call the base class method which has been overridden.

    function BaseClass(divID) 
    { 
               
        alert("  Base class constructor"); 
        this.divID=divID;
       
        
        //this method doesn't need to be called from the derived class!
        this.SayHello = SayHello;
        
        function SayHello()
        {
              alert ("Base class SayHello() '"+this.divID+"'");
        } 
   
  
     //this method must be overridden in the derived class
      BaseClass.prototype.SayGoodbye = function(arg) 
      { 
            alert("Base class SayGoodbye(): '"+this.divID+"' "+arg); 
      }                 
        
	          
    } 
   
   
   
    function DerivedClass(divID) 
    { 
   
        alert("  Derived class constructor"); 
        
       //call base class constructor          
        BaseClass.call (this,divID); 
          
         //override method 
        DerivedClass.prototype.SayGoodbye = function(arg) 
        { 
            //call the base class version !
                      
            BaseClass.prototype.SayGoodbye.call(this,arg); 
            alert("Derived class SayGoodbye(): '"+this.divID+"' "+arg); 
        } 
           
    } 

   var b = new BaseClass("base class"); 
   b.SayGoodbye(102);     
   b.SayHello(); 

    var d = new DerivedClass("derived class"); 
    d.SayGoodbye(102);     
    d.SayHello();

function Animal () {//code goes here } // notice the space between Animal and the left paranthesis
function Dog (){  this.Animal(); }   // this will generate error in IE
copyPrototype( Dog, Animal); //

The reason is that the regexp in copyPrototype used to match the parent’s constructor will also match the space after (and before) the constructor’s name. Hence instead of grabbing “Animal” only, the pattern will also grab “Animal ” instead. Firefox, however, resolve this just fine. IE, on the other hand, will give out a nasty and almost unidentifiable result in the call this.Animal() in the Dog’s constructor. This bug took me almost 2 days to slowly work through and discover.

So here is the new fix snippet of copyPrototype() that will work with any type of function declarations:

function copyPrototype(descendant, parent) {
    var sConstructor = parent.toString();
    var aMatch = sConstructor.match( /\s*function (.*)\s*\(/ );
	
    var sConstructor = parent.toString();
    var aMatch = sConstructor.match( /\s*function (.*)\(/ );	
	if ( aMatch != null ) { descendant.prototype[aMatch[1].replace(/^\s*|\s*$/g,"")] = parent; } 
		descendant.prototype[ aMatch[1] ] = parent; 
    for (var m in parent.prototype)
        descendant.prototype[m] = parent.prototype[m];
}

What I have added here is

aMatch[1].replace(/^\s*|\s*$/g,"") to trim the space before and after function name before the assignment. This updated code has proved to work well in my test cases.

Cheers!

Alex Le at http://www.alexle.net