»method modifiers« [Function.before], [Function.after], ...

[peterS.]

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:

1. 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. - [e-mail]