hallo again Janick,
ich habe das jetzt so gelöst, dass ich die Referenz der Methode
auf eine andere Methode gesetzt habe. ...
...
var origDoSth = self.DoSth;
self.DoSth = self.DoSth2;
> ...
> In dieser Methode führe ich dann den additiven Code aus,
> und anschließend rufe ich die ursprüngliche Methode auf.
> ...
> ~~~javascript
function DoSth2() {
> // my code
> // bla blub
>
> // call original
> origDoSth()
> }
der von mir vorgeschlagene Ansatz orientiert sich ähnlich, ...
(code Deines erstenn Postings):
Also aus
function DoSth() {
alert("nein");
}
> >
> > soll werden
> > ~~~javascript
function DoSth() {
> > alert("ja");
> > alert("nein");
> > }
... vermeidet es aber, zusätzliche Referenzen im globalen Namensraum
anzulegen. Stattdessen wird die Funktionalität der schon vorhandenen
globalen [DoSth]
-Referenz in einem Rutsch wie folgt neu definiert:
- speichere die zuletzt bekannte
[DoSth]
-Referenz als
[formerDoSomething]
durch eine anonyme Funktion, welche
sofort ausgeführt wird, ...
DoSth = (function (formerDoSomething) {
... // (siehe Code-Fragment [2])
})(DoSth);
2) ... dabei neue Funktionalität erzeugt, die wiederum jederzeit auf
`[formerDoSomething]`{:.language-javascript} zurückgreifen kann (siehe Code-Fragment [2]),
und ebendiese neue Funktion dann auf das bisher vorhandene `[DoSth]`{:.language-javascript}
"zurückschreibt" (siehe Code-Fragment [1]).
> ~~~javascript
...
> return (function () {
»»
> alert("ja");
> formerDoSomething();
> });
> ...
Die Lösung zur Aufgabenstellung läßt sich auf Metha-Ebene elegant lösen, indem
[Function.prototype]
um geeignete sogenannte »method modifier«s aufgewertet wird.
[Function.before]
, [Function.after]
, [Function.embed]
oder [Function.replace]
bieten sich da an ...
... Beispiel-Code wie immer auf die jconsole.com loslassen.
Function.prototype.before = (function (fctBefore) {
var fct = this;
if ((typeof fctBefore == "function") && (typeof fct == "function")) {
fct = (function (before, after) {
return (function () {
before();
return after();
});
})(fctBefore, fct);
}
return fct;
});
Function.prototype.after = (function (fctAfter) {
var fct = this;
if ((typeof fctAfter == "function") && (typeof fct == "function")) {
fct = (function (before, after) {
return (function () {
before();
return after();
});
})(fct, fctAfter);
}
return fct;
});
print("\n");
(function () {
print("01");
}).after(function () {
print("02");
})();
print("\n");
(function () {
print("01");
}).before(function () {
print("02");
})();
Eine durch diesen Thread angestoßene und mit diesem Post umgesetzte
Implementierung von [before], [after], [embed] und [replace] für das
[Function]
-Objekt findet sich auf meiner Dauerbaustelle.
so long - peterS. - pseliger@gmx.net
»Because objects in JavaScript are so flexible, you will want to think differently about class hierarchies.
Deep hierarchies are inappropriate. Shallow hierarchies are efficient and expressive.« - Douglas Crockford
ie:( fl:) br:> va:( ls:& fo:) rl:) n3;} n4:} ss:} de:µ js:} mo:? zu:]