Here is a link to an article which compares various techniques to implement inheritance in JavaScript (and their benefits and drawbacks):

http://www.soft-amis.org/jsiner/inheritance.html

> My preferred approach is more along the lines of:

> function Cat.prototype.meow(){…}

As has been pointed out to me, Firefox chokes on this syntax. I’ve been using WSH to run Javascript, so never tried it in a browser. It does work in IE, but not Firefox, so my approach is probably out for usage where you do not control script host.

Jim Plush wrote:

“If you want to see pretty classes you could always do this:…”

I like Jim’s approach.

If you want to see pretty classes you could always do this:

function myClass() {}

myClass.prototype = {

test:function() {

alert(‘hi’);
},

test2:function() {
// something here
}
};

“I prefer to assign the methods within the main function…Any advantages or disadvantages to using this over prototype?”

I used to prefer your method, too, but performance is significantly worse with your approach because every time you instantiate an object, a new function is created.

Mind you, most people treat Javascript as kind of a toy language and don’t expect much performance from it, but detach the interpreter from the browser and you can write quite powerful programs with decent performance.

My preferred approach is more along the lines of:

function Cat.prototype.meow(){…}

rather than

Cat.prototype.meow = function(){…}

These work slightly different as functions (and, in this case, methods) declared like mine exist when the first line of the program executes. Using the “Cat.prototype.meow = function” approach, the method will only exist after the program has executed that line of code. Thus, my program could begin with the lines:

var mistigri = new Cat(‘Mistigri’);
mistigri.meow();

Whereas the “Cat.prototype.meow = function” approach would choke on that, since the meow method does not exist yet.

Class Test {
public void tryMe() {
System.out.println(“tried”);
}
}

Where as, using the prototype technique, you don’t get such an enclosed view. I don’t tend to see this as a disadvantage, rather as something that will be visually more appealing.

The disadvantage of doing it that way is that it uses more memory. You can see in another of my post about advatages of using prototypes : “It uses less memory because javascript creates only one instance of the function and uses references to it.” (http://www.javascriptkata.com/2007/03/21/what-are-javascript-prototypes-short-answer-for-advanced-javascripters/).

Thanks for the comment!