It variates from time to time, but if I test some rounds I see appr. this results.

@Michael .H you not?

The most important points of my implementation are:

1. User will work with constructor to create a class, not with object – private class variables and functions are possible.
2. I think at the moment when browser rendering any constructor it hasn’t to initialize all the stuff the constructor contains
3. I can use more classical order pattern inside of the constructor. (first private variables, then privileged, then public methods and then private methods)
4. access overwritten methods via _super
5. Pass any variables to constructor, so they can be used everywere in the class, without to have to map over them, like if you do it over init method

Speedtest shows that my implementation is slower than j3Class or wr Class, but it still much faster than all other famous implementations.

Probably you have some Ideas how I can impove the performance without to change the usability?

http://dev.ajaxsoft.de/classtest/

One problem with parasitic inheritance is that it doesn’t provide a simple way for subclasses to inject behavior into super classes. For example, if a subclass needs to add a “onAfterFoo” callback to the foo() method of a superclass, how is that accomplished with parasitic inheritance?

With classic inheritance, the subclass need only define a foo() method that looks something like this:

function() {
this.parent.foo();
this.onAfterFoo();
}

But with parasitic inheritance you have to cobble together some way of preserving a reference to the parent implementation before overriding the foo() method. And, to date, I have yet to see an elegant solution to that problem that doesn’t look a lot like the classic inheritance solutions you feel are wrong.

I’d rather use the method Doug Crockford outlines as parasitic inheritance. You can’t call a parent method from within an overriding method, it’s a little slower on instantiation, but runs par with parent method invocation. It also makes for much cleaner code, being able to pass parameters into the parent class creation, and allowing for private members via closures.