traceMessages

[hOk]

Hi Leute,

des öfteren will man ja wissen welche Methoden eines Objektes
in welcher Reihenfolge aufgerufen werden. Mir ist gerade aufge-
fallen, dass man dieses ganz einfach lösen kann, in dem man die
Orginalmethode überschreibt und innerhalb der neuen Methode
einen trace macht und dann die Orginalmethode aufruft.

In anderen Sprachen wie Java, C++ oder PHP wäre das wohl nicht
so einfach, da soll nochmal jemand behaupten Actionscript wäre
keine mächtige Sprache...:-)

traceMessages = function (obj) {
    for (var p in obj) {
        if (typeof obj[p] != 'function') continue;
        var tmp = obj[p];
        obj[p] = function() {
            trace('call-of> ' + arguments.callee.__methodName);
            arguments.callee.__originalMethod.apply(this, arguments);
        }
        obj[p].__methodName = p;
        obj[p].__originalMethod = tmp;
    }
    return '';
}
 
// Test:
Kaefer = function () {}
Kaefer.prototype.init = function (pStrName, pIntAge) {
    this.strName = pStrName;
    this.intAge = pIntAge;
}
Kaefer.prototype.traceProperties = function () {
    trace(this.strName + '(' + this.intAge + ')');
}
 
objPaule = new Kaefer();
 
traceMessages(objPaule); // <--
 
objPaule.init('Paule', '23');
objPaule.traceProperties();
 
// Output:
// 
// call-of> init
// call-of> traceProperties
// Paule(23) 
 
 

nette Grüße, Holger

[bokel]

Hi Holger,
coole Idee,
da spart man sich doch einen Haufen Schreibarbeit.

Hier ist noch eine etwas andere Version,
die die jeweils zuletzt zugwiesene Methode traced.
Dann kann man selektieren, was man tracen will und was nicht, ohne dass man den Namen angeben muss.

traceLastMessages = function (obj) {
    for (var p in obj) {
        if (typeof obj[p] != 'function') {
        } else {
            var tmp = obj[p];
            obj[p] = function () { trace('call-of> ' + arguments.callee.__methodName);arguments.callee.__originalMethod.apply(this, arguments);};
            obj[p].__methodName = p;
            obj[p].__originalMethod = tmp;
        }
        return;
    }
};
 
// Test:
Kaefer = function () {
};
Kaefer.prototype.init = function(pStrName, pIntAge) {
    this.strName = pStrName;
    this.intAge = pIntAge;
};
traceLastMessages(Kaefer.prototype);
 
Kaefer.prototype.traceProperties = function() {
    trace(this.strName + '(' + this.intAge + ')');
};
 
traceLastMessages(Kaefer.prototype);
 
objPaule = new Kaefer();
// <--
objPaule.init('Paule', '23');
objPaule.traceProperties();
// Output:
//
// call-of> init
// call-of> traceProperties
// Paule(23) 
 
 

Vielen Dank für die gute Idee,
mfg r.

[bokel]

Hehe,
und wo wir schonmal dabei sind,
hier ist noch eine Version, die mit resolve arbeitet:

traceMessages = function (obj) {
    for (var p in obj) {
        obj["_" + p] = obj[p];
        delete obj[p];
    }
};
 
// Test:
Kaefer = function () {
};
Kaefer.prototype.init = function(pStrName, pIntAge) {
    this.strName = pStrName;
    this.intAge = pIntAge;
};
//traceLastMessages(Kaefer.prototype);
Kaefer.prototype.traceProperties = function() {
    trace(this.strName + '(' + this.intAge + ')');
};
 
Kaefer.prototype._resolve = function(name){
    trace("resolve " + arguments);
    return this["_" + name];
}
 
traceMessages(Kaefer.prototype);
 
 
//traceLastMessages(Kaefer.prototype);
 
objPaule = new Kaefer();
// <--
objPaule.init('Paule', '23');
objPaule.traceProperties();
// Output:
//
// call-of> init
// call-of> traceProperties
// Paule(23) 
 
 

mfg r.

[hOk]

Hehe, die __resolve würde ich aber dafür nicht
verschwenden, aber genial ist es auf alle Fälle...;-)
Hier nochmal mit Arguments und OnlyLastMethod-
Flag.
Kann man es nicht mit irgendeinem ASNative schaffen
an den Text der Funktion ranzukommen?
In Javascript ist das ja das normale toString-Verhalten
einer Funktion.
Wäre halt Klasse wenn man die erwarteten Argumente-
Bezeichner mit ausgeben könnte.
*grübel*

trace(String(traceMessages = function (pObj, pBlnLastMethodOnly) {
    for (var p in pObj) {
        if (typeof pObj[p] != 'function') continue;
        var tmp = pObj[p];
        pObj[p] = function() {
            trace('call-of> ' + arguments.callee.__methodName + '(' + arguments.join(', ') + ')');
            arguments.callee.__originalMethod.apply(this, arguments);
        }
        pObj[p].__methodName = p;
        pObj[p].__originalMethod = tmp;
        if (pBlnLastMethodOnly) return '';
    }
    return '';
}).substr(0,0));
 
// Test
Kaefer = function () {}
Kaefer.prototype.init = function (pStrName, pIntAge) {
    this.strName = pStrName;
    this.intAge = pIntAge;
}
Kaefer.prototype.traceProperties = function () {
    trace(this.strName + '(' + this.intAge + ')');
}
 
objPaule = new Kaefer();
 
trace(traceMessages(objPaule)); // <--
 
objPaule.init('Paule', '23');
objPaule.traceProperties();
 
// Output:
// 
// call-of> init(Paule, 23)
// call-of> traceProperties()
// Paule(23) 
 
 

[bokel]

Eine Methode kenne ich,
dazu muss man eine Funktion innerhalb der zu tracenden
Funktion definieren, dann hat man Zugriff auf das Activation-
Objekt der aeusseren Funktion.

function eins(a,b,c){
    function tracer(){
        for(var i in this) trace(i);
    }
    tracer();
}
 
eins(1,2,3);
 
ausgabe
tracer
c
b
a
arguments 
 

Die innere Funktion könnte man in eine include-Datei legen,
und überall dort wo man sie braucht, includen.

Nicht besonders schön

mfg r.

[hOk]

Stimmt, da hast du recht, schade eigentlich.

PS.: Lese gerade den Fowler, war ein super
Tip, hat auch mein Denken verändert...:-)

[bokel]

sach ich doch

ich habe gerade die design patterns bestellt.
ich bin gespannt, ich habe nämlich gerade ein
groesseres projekt abgeschlossen, bei dem
das sicher nützlich gewesen wäre

mfg r.

[tumetom]

heir passen vieleicht folgene sachen ganz gut rein:


Mich hat es beim debuggen hin und wieder gestört, dass ich nicht wusste welcher Klasse eine instanz angehört.


typeof ist da nur bedingt hilfreich.


damit gehts aber eigentlich ganze gut...:

Function.prototype.subscribe = function(name) {
    if (Function.reference == null) {
        Function.reference = [];
    }
    var ref = Function.reference;
    this.unSubscribe();
    this.counter++;
    ref.push([this.prototype, name, this.counter]);
    return true;
};
 
 
 
 
 
 
 
 
Function.prototype.unSubscribe = function() {
    var ref = Function.reference;
    var max = ref.length;
    for (var i = 0; i<max; i++) {
        if (ref[i][0] == this.prototype) {
            ref.splice(i, 1);
            return true;
        }
    }
    return false;
};
 
 
 
//Anfügen einiger  internen Klassen 
Array.subscribe("Array");
Date.subscribe("Date");
Function.subscribe("Function");
Object.subscribe("Object");
String.subscribe("String");
Number.subscribe("Number");
Selection.subscribe("Selection");
Color.subscribe("Color");
MovieClip.subscribe("MovieClip");
Sound.subscribe("Sound");
TextField.subscribe("TextField");
 
 
Object.prototype.getID = function() {
    var ref = Function.reference;
    var max = ref.length;
    for (var i = 0; i<max; i++) {
        if (ref[i][0] == this.__proto__) {
            return ref[i][1];
        }
    }
    return false;
};
 
 
Object.prototype.toString = function(arg) {
    var ID = this.getID();
    var str = ASnative(101, 4);
    if (ID != false && arg != true) {
        return str()+"  -  "+ID;
    } else {
        return str();
    }
};
 
 
 
 
 
 
 
 
 
myArray=[]
 
trace(myArray) // ausgabe:  [Object-Object]   - Array
 
 
 
_global.klasse=function(){
    
    //...}
    
klasse.subscribe("Klasse")
    
    
 
    
    myClass=new Klasse()
    
    trace(myClass)  // ausgabe:  [Object-Object]   - Klasse
    trace(myClass.getID())   // ausgabe  Klasse 
 
 

MFG tumetom

[bokel]

@hok
Arg, jetzt habe ich gerade ne Stunde verloren,
bis ich gemerkt habe, dass die Ersatz-Routinen
von traceMessages kein Ergebnis liefern.
Das wird teuer für dich

@tumetom
Das sieht wild aus

Eine andere Möglichkeit ist die Zuweisung des Namens an
die Klasse: Klasse.classname = "MeineKlasse" und die Abfrage
von this.constructor.classname in der Instanz.

mfg r.

[tumetom]

hmm oder gleich als prototype... dann kann man sich den umweg über dne Konstruktor sparen..
warum so einfach wenns auch so schön kompliziert geht...??



Wies nicht emhr genau was.. aber irgendwas hab ich mir dabei wohl mal gedacht

[hOk]

@tumetom
Sieht wirklich interessant aus, nur mit dem Array funktionierts
nicht, Array hat ja sein eigene toString, die den join(',') macht.

@bokel
Hups, dafür haste jetzt einen gemeinen Käfer bei mir gut...:-)

Hier ist noch eine neue Version, die bei jeder Nachricht die
Millisekunden seit der letzten Nachricht ausgibt. Den Bug habe
ich natürlich rausgenommen...:-)

Werde es wohl nochmal ändern, so dass die Zeit ausgeben wird
die der Methoden-Aufruf verbraucht hat, dann hat man einen
schönen Performance-Profiler.

netten Gruß, Holger

trace(String(traceMessages = function (pObj, pBlnLastMethodOnly) {
    for (var p in pObj) {
        if (typeof pObj[p] != 'function') continue;
        var tmp = pObj[p];
        pObj[p] = function() {
            var t = getTimer() - arguments.callee.__traceMessages.intLastCallTime;
            arguments.callee.__traceMessages.intLastCallTime = getTimer();
            trace('<call-of ['+t+']> ' + arguments.callee.__methodName + '(' + arguments.join(', ') + ')');
            return arguments.callee.__originalMethod.apply(this, arguments);
        }
        pObj[p].__methodName = p;
        pObj[p].__originalMethod = tmp;
        pObj[p].__traceMessages = arguments.callee;
        if (pBlnLastMethodOnly) return '';
    }
    return '';
}).substr(0,0)); 
 

[bokel]

@hok
Das mit dem Profiler ist eine gute Idee. Man koennte auch gleich
noch die Werte für einzelne Funktionen aufaddieren, dann sieht
man direkt in welchen Funktionen insgesamt die meiste Zeit verbracht wird und wo es sich am ehesten lohnt zu optimieren.

@tumetom
=)


mfg r .

[bokel]

@hok
Ich habe es noch nicht genau analysiert,
aber ich glaube, wenn man mit Vererbung
arbeitet, gibt es irgendwie auch Probleme
mit traceMessages. Ich bekomme da manchmal
den Rekursionsfehler (256 Stufen).

--------------
So jetzt sind die "Design Patterns" (Gamma et. al.) da.

Das geht ja schon gleich gut los mit der Beschreibung eines
Wysiwig-Editors in OOP. Interessant finde ich die Aussage,
der Komposition gegenüber der Vererbung den Vorzug zu geben.

Da muss ich auch erstmal drüber nachdenken, wie das in meinen
Projekten aussehen würde. Das Problem, dass Änderungen von
Oberklassen u. U. zu Anpassungen in Subklassen führen können,
ist mir auch schon untergekommen. Die Komposition ist aber halt
auch immer etwas aufwendiger, wegen der Weiterleitung an
das betreffende Objekt.

Im Vergleich zum Fowler würde ich sagen, dass das Buch ein
wesentlich höheres Abstraktionsniveau behandelt. Den Fowler
kann jeder Programmierer gebrauchen, der seinen Stil
verbessern möchte, das hier ist schon eher was für Leute
mit viel Erfahrung in OOP.

mfg r.

[hOk]

Ja das denke ich auch.
Zum Thema Komposition versus Generalisierung:
Ich denke das was die GOF meinen ist, das man
nicht ohne wirklich trifftigen Grund generalisieren
soll, sondern nur dann wenn man abstrakte
Gemeinsamkeiten feststellt. Oft wird ja, geerbt
um mal eben noch mehr Funktionalitäten in einer
Klasse zu haben. Ich denke die GOF wollen einfach
nur, die auch von Fowler beschriebene, semantische
Distanz zwischen Methoden und Klasse vermeiden.
nette Gruß, Holger

[kelor]

gefällt mir der threat...
hier habe ich noch was, dass den klassennamen der klasseninstanz zur verfügung stellt und zeitgleich der klasse und der instanz, jeweils ihren namen ausgibt...

/*******************************************\
     function _getName (hier in _global definiert...geht aber überall...)
     inkl. Function.prototype.getter
/*******************************************/
_global._getName = function (calling,tar) {
        var props,temp;
        tar=(tar==undefined) ? _root : tar;
        this=(calling==undefined) ? this : calling;
        for (props in tar) {
                if (tar[props]==this ) return props;
                else  if (typeof tar[props]=="movieclip" ){
                        temp=this._getName(this,tar[props]);
                        if (temp!=undefined) return temp;
                }
        }
}
Function.prototype.addProperty("_ownName",_getName,null);
/**************************************
 ende der globalen getName-fkt inkl. Function.prototype
**************************************/
 
/***************************************
 klassenerzeugungsfunktion createClass
***************************************/
 
_global.createClass=function(tar,name){
            var nm = name;
            var tar=tar;
            tar[nm]=function(){
                this._className=this.constructor._ownName;
            }
            tar[nm].prototype.addProperty("_ownName",_getName,null);
            delete nm, tar;
}
/**********************************************
  ende der erzeugungsfunktion
------------------------------------------
funktion createClass nimmt 2 parameter...
1.parameter : zeitleiste
2.parameter : name der neuen funktion, als string!
**********************************************/
 
 
 
// erzeugen der klasse 'dideldum' auf aktueller zeitleiste
createClass(this,'dideldum');
 
ASSetPropFlags(dideldum,'prototype',0,1);
// erzeugen eines abkömmlings von 'dideldum' mit dem namen 'diddel'
diddel = new dideldum();
 
// kindsobjekt nach dem namen der klasse fragen, von dem es stammt...
// dem eigenen namen
// und mutterlement(die klasse) fragen, ob sie weiß, wie sie heißt...
trace('diddel._className = '+diddel._className);
trace('diddel._ownName = '+diddel._ownName);
trace('dideldum._ownName = '+this[diddel._className]._ownName); 
 

output:
diddel._className = dideldum;
diddel._ownName = diddel;
dideldum._ownName = dideldum

bezüglich der argumente in _getName(calling...) hatte ich hier noch das problem dass ich 'this' von außerhalb der fkt nicht gezielt ansteuern konnte....*grübel*
deshalb hatte ich es als argument mit an die fkt übergeben...
*anyideas?*

vielleicht hilft´s ja, dem ein oder anderen...

oder passte das jetzt nicht hierher..? *gugg*

greetz

kelor