Pseudoklassen

[Struppi]

Und ja, in einem zweiten Schritt möchte einen guten weg finden, ohne den Overhead von Mootools und co., weniger schreib-intensive, übersichtliche und doch noch performante, "classen/prototypen" zu schreiben.

Performant ist eigentlich nur der Standard JS Weg. Alles andere geht Umwege, weil die Vererbung in JS etwas komplizierter ist und es keine vorgefertigten Funktionen gibt, um z.b. auf SUPER Funktionen zu zugreifen.

Das wird z.b. bei Mootools umgesetzt, zum Preis, dass das erzeugen von eigenen Objekten um den Faktor zehn langsamer ist.

Vieleicht hast du noch weitere Ideen?

Dein Weg, bringt erstmal gar nichts, wie molily schon schrieb, ist es einfach nur ein etwas verquerer Weg, ein eignes Objekt zu erzeugen. Das ganze erinnert leicht an den Ansatz von Crockford, mit dem es möglich ist eine Vererbung in JS umzusetzen, die nicht den Konstruktor des parent Objekt aufruft.

Mein aktueller Ansatz, der eine Mischung aus diversen Frameworks ist, sieht so aus:

Function.prototype.Extend = function(b) {  
    var o = this;  
    var proto = b.prototype || b;  
  
    function Chain() {}  
    Chain.prototype = proto;  
  
    function Class() {}  
    Class.prototype = new Chain;  
  
    // inherit the prototype of this Function  
    for(var f in o.prototype) {  
        Class.prototype[f] = o.prototype[f];  
        // function has a super function  
        if(typeof Class.prototype[f] == 'function') Class.prototype[f]._super = proto[f];  
    }  
    o.prototype = Class.prototype;  
    o.prototype.constructor = o;  
  
    o.prototype._parent = b;  
  
    Class.prototype._super = function() {  
		var c = Class.prototype._super.caller;  
		  
        if(!c._super && this._parent) { // Konstruktorcall  
	    var parent = this._parent, ret;  
            var proto = o.prototype;  
  
            this._parent = this._parent.prototype._parent;  
            ret = parent.apply(this, arguments);  
            this._parent = parent;  
            return ret;  
	} else if(!c._super) throw new Error('Function has no _super function.\n' + c +'');  
        return c._super.apply(this, arguments)  
    }  
}  

Das ist ein Kompromiss zwischen flexibilität und Geschwindigkeit. Aber es lassen sich Funktionen als Konstruktor nutzen, so wie es in JS momentan vorgesehen ist.

Struppi.