Programmgesteuertes Hinzufügen von Code zu einer Javascript-Funktion

Ich versuche, eine vorhandene JS-Bibliothek anzupassen, ohne den ursprünglichen JS-Code zu ändern. Dieser Code wird in einige externe JS-Dateien geladen, auf die ich Zugriff habe. Ich möchte eine der in der Originaldatei enthaltenen Funktionen ändern, ohne das Ganze zu kopieren und in die zweite JS-Datei einzufügen.
So könnte beispielsweise das Off-Limits-JS eine Funktion wie die folgende haben:

var someFunction = function(){
    alert("done");
}

Ich möchte in der Lage sein, JS-Code irgendwie an diese Funktion anzuhängen oder voranzustellen. Der Grund ist in erster Linie, dass die Funktion in der ursprünglichen unberührbaren JS ziemlich groß ist und wenn diese JS jemals aktualisiert wird, ist die Funktion, mit der ich sie überschreibe, veraltet.

Ich bin mir nicht ganz sicher, ob dies möglich ist, aber ich dachte, ich würde es überprüfen.

Wenn someFunctiones global verfügbar ist, können Sie die Funktion zwischenspeichern, eine eigene erstellen und von Ihrer Funktion aufrufen lassen.

Also, wenn dies das Original ist ...

someFunction = function() {
    alert("done");
}

Du würdest das tun ...

someFunction = (function() {
    var cached_function = someFunction;

    return function() {
        // your code

        var result = cached_function.apply(this, arguments); // use .apply() to call it

        // more of your code

        return result;
    };
})();

Hier ist die Geige

Beachten Sie, dass ich .applydie zwischengespeicherte Funktion aufrufe. Auf diese Weise kann ich den erwarteten Wert von beibehalten thisund alle übergebenen Argumente als einzelne Argumente übergeben, unabhängig davon, wie viele vorhanden waren.

Speichern Sie zuerst die eigentliche Funktion in einer Variablen.

var oldFunction = someFunction;

dann definieren Sie Ihre eigenen:

someFunction = function(){
  // do something before
  oldFunction();
  // do something after
};

Sie können eine Funktion erstellen, die Ihren Code aufruft und dann die Funktion aufruft.

var old_someFunction = someFunction;
someFunction = function(){
    alert('Hello');
    old_someFunction();
    alert('Goodbye');
}

Ich weiß nicht, ob Sie die Funktion aktualisieren können, aber je nachdem, wie auf sie verwiesen wird, können Sie an ihrer Stelle eine neue Funktion erstellen:

var the_old_function = someFunction;
someFunction = function () {
    /* ..My new code... */
    the_old_function();
    /* ..More of my new code.. */
}

Ebenfalls. Wenn Sie den lokalen Kontext ändern möchten, müssen Sie die Funktion neu erstellen. Beispielsweise:

var t = function() {
    var a = 1;
};

var z = function() {
    console.log(a);
};

Jetzt

z() // => log: undefined

Dann

var ts = t.toString(),
    zs = z.toString();

ts = ts.slice(ts.indexOf("{") + 1, ts.lastIndexOf("}"));
zs = zs.slice(zs.indexOf("{") + 1, zs.lastIndexOf("}"));

var z = new Function(ts + "\n" + zs);

Und

z() // => log: 1

Dies ist jedoch nur das einfachste Beispiel. Es wird noch viel Arbeit erfordern, um mit Argumenten, Kommentaren und Rückgabewerten umzugehen. Darüber hinaus gibt es noch viele Fallstricke.
toString | Scheibe | indexOf | lastIndexOf | neue Funktion

Das Proxy-Muster (wie von user1106925 verwendet) kann in eine Funktion eingefügt werden. Die unten beschriebene Funktion bezieht sich auf Funktionen, die nicht im globalen Bereich liegen, und sogar auf Prototypen. Sie würden es so verwenden:

extender(
  objectContainingFunction,
  nameOfFunctionToExtend,
  parameterlessFunctionOfCodeToPrepend,
  parameterlessFunctionOfCodeToAppend
)

Im folgenden Snippet können Sie sehen, wie ich die Funktion zum Erweitern von test.prototype.doIt () verwende.

// allows you to prepend or append code to an existing function
function extender (container, funcName, prepend, append) {

    (function() {

        let proxied = container[funcName];

        container[funcName] = function() {
            if (prepend) prepend.apply( this );
            let result = proxied.apply( this, arguments );
            if (append) append.apply( this );
            return result;
        };

    })();

}

// class we're going to want to test our extender on
class test {
    constructor() {
        this.x = 'instance val';
    }
    doIt (message) {
        console.log(`logged: ${message}`);
        return `returned: ${message}`;
    }
}

// extends test.prototype.doIt()
// (you could also just extend the instance below if desired)
extender(
    test.prototype, 
    'doIt', 
    function () { console.log(`prepended: ${this.x}`) },
    function () { console.log(`appended: ${this.x}`) }
);

// See if the prepended and appended code runs
let tval = new test().doIt('log this');
console.log(tval);