Funktion zur Laufzeit erweitern

[Janick]

Hallo,

ich habe mal eine Frage.

Kann ich mittels JavaScript zur Laufzeit den Code einer Funktion erweitern?

Also aus

function DoSth() {  
  alert("nein");  
}

soll werden

function DoSth() {  
  alert("ja");  
  alert("nein");  
}

Es geht mir hierbei rein um das Interesse. Wie fragwürdig das ganze ist sei mal dahin gestellt.

Vielen Dank
Janick

[ChrisB]

Hi,

Kann ich mittels JavaScript zur Laufzeit den Code einer Funktion erweitern?

Jein.

Du kannst die Funktion natürlich überschreiben - mit einer neuen Definition, ggf. auch aus Code in Stringform eine Funktion erstellen lassen.

MfG ChrisB

[peterS.]

gruss Janick,

Kann ich mittels JavaScript zur Laufzeit den Code einer Funktion erweitern?

nein, das geht nicht ...

Also aus

function DoSth() {

alert("nein");
}

>   
> soll werden  
> ~~~javascript

function DoSth() {  

>   alert("ja");  
>   alert("nein");  
> }

... eine mögliche Variante des »method modyfying«s in JavaScript würde
beispielsweise die originale [DoSth]-Referenz unter zuhilfenahme des
Module-Patterns so überschreiben, dass neue Funktionalität zusammen mit
der originalen [DoSth]-Methode auf ihr abgebildet wird ...

... code:

function DoSth() {  
  alert("nein");  
}  
alert(DoSth);  
DoSth();  
  
  
DoSth = (function (formerDoSomething) { // closure  
  return (function () { // method modifyer  
  
    alert("ja");  
    formerDoSomething();  
  });  
})(DoSth);  
  
alert(DoSth);  
DoSth();

so long - peterS. - [e-mail]

[Janick]

Hallo,

ich habe das jetzt so gelöst, dass ich die Referenz der Methode auf eine andere Methode gesetzt habe. In dieser Methode führe ich dann den additiven Code aus, und anschließend rufe ich die ursprüngliche Methode auf.

  
var origDoSth = self.DoSth;  
self.DoSth = self.DoSth2;  
  
function DoSth2() {  
  // my code  
  // bla blub  
  
  // call original  
  origDoSth()  
}

Grüße,
Janick

ich habe mal eine Frage.

Kann ich mittels JavaScript zur Laufzeit den Code einer Funktion erweitern?

Also aus

function DoSth() {

alert("nein");
}

>   
> soll werden  
> ~~~javascript

function DoSth() {  

>   alert("ja");  
>   alert("nein");  
> }

Es geht mir hierbei rein um das Interesse. Wie fragwürdig das ganze ist sei mal dahin gestellt.

Vielen Dank
Janick

[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]