Aggiunta di codice a una funzione javascript a livello di codice

Sto tentando di personalizzare una libreria JS esistente senza modificare il codice JS originale. Questo codice viene caricato in alcuni file JS esterni a cui ho accesso e quello che vorrei fare è modificare una delle funzioni contenute nel file originale senza copiare e incollare l'intera cosa nel secondo file JS.
Quindi, ad esempio, il JS off limits potrebbe avere una funzione come questa:

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

Mi piacerebbe essere in grado in qualche modo di aggiungere o anteporre del codice JS in quella funzione. Il motivo è principalmente che nel JS intoccabile originale la funzione è piuttosto enorme e se quel JS viene aggiornato, la funzione con cui lo sovrascrivo sarà obsoleta.

Non sono del tutto sicuro che sia possibile, ma ho pensato di controllare.

Se someFunctionè disponibile a livello globale, puoi memorizzare la funzione nella cache, crearne una tua e farla chiamare dalla tua.

Quindi se questo è l'originale ...

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

Faresti questo ...

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;
    };
})();

Ecco il violino

Si noti che utilizzo .applyper chiamare la funzione memorizzata nella cache. Questo mi consente di mantenere il valore atteso di thise di passare tutti gli argomenti passati come argomenti individuali indipendentemente da quanti erano.

prima memorizzare la funzione effettiva in una variabile ..

var oldFunction = someFunction;

quindi definisci il tuo:

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

Puoi creare una funzione che chiama il tuo codice e quindi chiama la funzione.

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

Non so se puoi aggiornare la funzione, ma a seconda di come viene referenziato, puoi creare una nuova funzione al suo posto:

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

Anche. Se vuoi cambiare il contesto locale devi ricreare function. Per esempio:

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

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

Adesso

z() // => log: undefined

Poi

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);

E

z() // => log: 1

Ma questo è solo l'esempio più semplice. Ci vorrà ancora molto lavoro per gestire argomenti, commenti e valore di ritorno. Inoltre, ci sono ancora molte insidie.
toString | fetta | indexOf | lastIndexOf | nuova funzione

Il modello proxy (utilizzato da user1106925) può essere inserito in una funzione. Quello che ho scritto di seguito funziona su funzioni che non rientrano nell'ambito globale e persino sui prototipi. Lo useresti in questo modo:

extender(
  objectContainingFunction,
  nameOfFunctionToExtend,
  parameterlessFunctionOfCodeToPrepend,
  parameterlessFunctionOfCodeToAppend
)

Nello snippet qui sotto, puoi vedermi usare la funzione per estendere test.prototype.doIt ().

// 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);