Remplacer une fonction JavaScript lors du référencement de l'original

J'ai une fonction,, a()que je veux remplacer, mais aussi que l'original a()soit exécuté dans un ordre dépendant du contexte. Par exemple, parfois, lorsque je génère une page, je souhaite remplacer comme ceci:

function a() {
    new_code();
    original_a();
}

et parfois comme ceci:

function a() {
    original_a();
    other_new_code();
}

Comment puis-je obtenir cela original_a()de la circonscription principale a()? Est-ce même possible?

S'il vous plaît, ne suggérez pas d'alternatives à la surcharge de cette façon, j'en connais beaucoup. Je pose des questions sur cette façon spécifiquement.

Vous pouvez faire quelque chose comme ceci:

var a = (function() {
    var original_a = a;

    if (condition) {
        return function() {
            new_code();
            original_a();
        }
    } else {
        return function() {
            original_a();
            other_new_code();
        }
    }
})();

La déclaration à l' original_aintérieur d'une fonction anonyme l'empêche d'encombrer l'espace de noms global, mais elle est disponible dans les fonctions internes.

Comme Nerdmaster mentionné dans les commentaires, assurez-vous d'inclure le ()à la fin. Vous souhaitez appeler la fonction externe et stocker le résultat (l'une des deux fonctions internes) dans a, pas stocker la fonction externe elle-même a.

Le modèle Proxy peut vous aider:

(function() {
    // log all calls to setArray
    var proxied = jQuery.fn.setArray;
    jQuery.fn.setArray = function() {
        console.log( this, arguments );
        return proxied.apply( this, arguments );
    };
})();

Ce qui précède enveloppe son code dans une fonction pour masquer la variable «mandatée». Il enregistre la méthode setArray de jQuery dans une fermeture et l'écrase. Le proxy enregistre ensuite tous les appels à la méthode et délègue l'appel à l'original. L'utilisation de apply (this, arguments) garantit que l'appelant ne pourra pas remarquer la différence entre la méthode d'origine et la méthode mandatée.

Merci les gars, le modèle de proxy a vraiment aidé ..... En fait, je voulais appeler une fonction globale foo .. Dans certaines pages, j'ai besoin de faire quelques vérifications. J'ai donc fait ce qui suit.

//Saving the original func
var org_foo = window.foo;

//Assigning proxy fucnc
window.foo = function(args){
    //Performing checks
    if(checkCondition(args)){
        //Calling original funcs
        org_foo(args);
    }
};

Thnx cela m'a vraiment aidé

Vous pouvez remplacer une fonction en utilisant une construction comme:

function override(f, g) {
    return function() {
        return g(f);
    };
}

Par exemple:

 a = override(a, function(original_a) {
      if (condition) { new_code(); original_a(); }
      else { original_a(); other_new_code(); }
 });

Edit: Correction d'une faute de frappe.

Passer des arguments arbitraires:

a = override(a, function(original_a) {
    if (condition) { new_code(); original_a.apply(this, arguments) ; }
    else { original_a.apply(this, arguments); other_new_code(); }
});

La réponse que @Matthew Crumley fournit est d'utiliser les expressions de fonction immédiatement appelées, pour fermer l'ancienne fonction «a» dans le contexte d'exécution de la fonction retournée. Je pense que c'était la meilleure réponse, mais personnellement, je préférerais passer la fonction «a» comme argument à l'IIFE. Je pense que c'est plus compréhensible.

   var a = (function(original_a) {
        if (condition) {
            return function() {
                new_code();
                original_a();
            }
        } else {
            return function() {
                original_a();
                other_new_code();
            }
        }
    })(a);

Les exemples ci-dessus ne s'appliquent pas correctement thisou ne passent pas argumentscorrectement au remplacement de fonction. Underscore _.wrap () encapsule les fonctions existantes, s'applique thiset passe argumentscorrectement. Voir: http://underscorejs.org/#wrap

J'avais du code écrit par quelqu'un d'autre et je voulais ajouter une ligne à une fonction que je ne pouvais pas trouver dans le code. Donc, comme solution de contournement, je voulais le remplacer.

Aucune des solutions n'a fonctionné pour moi.

Voici ce qui a fonctionné dans mon cas:

if (typeof originalFunction === "undefined") {
    originalFunction = targetFunction;
    targetFunction = function(x, y) {
        //Your code
        originalFunction(a, b);
        //Your Code
    };  
}

J'ai créé un petit assistant pour un scénario similaire car j'avais souvent besoin de remplacer les fonctions de plusieurs bibliothèques. Cet assistant accepte un «espace de noms» (le conteneur de fonction), le nom de la fonction et la fonction de remplacement. Il remplacera la fonction d'origine dans l'espace de noms référencé par la nouvelle.

La nouvelle fonction accepte la fonction d'origine comme premier argument et les arguments de fonctions d'origine comme le reste. Cela préservera le contexte à chaque fois. Il prend également en charge les fonctions vides et non vides.

function overrideFunction(namespace, baseFuncName, func) {
    var originalFn = namespace[baseFuncName];
    namespace[baseFuncName] = function () {
        return func.apply(this, [originalFn.bind(this)].concat(Array.prototype.slice.call(arguments, 0)));
    };
}

Utilisation par exemple avec Bootstrap:

overrideFunction($.fn.popover.Constructor.prototype, 'leave', function(baseFn, obj) {
    // ... do stuff before base call
    baseFn(obj);
    // ... do stuff after base call
});

Je n'ai cependant créé aucun test de performance. Cela peut éventuellement ajouter des frais généraux indésirables qui peuvent ou ne peuvent pas être un gros problème, selon les scénarios.

À mon avis, les principales réponses ne sont pas lisibles / maintenables, et les autres réponses ne lient pas correctement le contexte. Voici une solution lisible utilisant la syntaxe ES6 pour résoudre ces deux problèmes.

const orginial = someObject.foo;
someObject.foo = function() {
  if (condition) orginial.bind(this)(...arguments);
};

Ma réponse a donc fini par être une solution qui me permet d'utiliser la variable _this pointant vers l'objet d'origine. Je crée une nouvelle instance d'un "carré" mais je détestais la façon dont le "carré" générait sa taille. J'ai pensé qu'il devrait suivre mes besoins spécifiques. Cependant, pour ce faire, j'avais besoin que le carré ait une fonction "GetSize" mise à jour avec les éléments internes de cette fonction appelant d'autres fonctions déjà existantes dans le carré telles que this.height, this.GetVolume (). Mais pour ce faire, je devais le faire sans aucun piratage fou. Voici donc ma solution.

Une autre fonction d'initialisation ou d'assistance d'objet.

this.viewer = new Autodesk.Viewing.Private.GuiViewer3D(
  this.viewerContainer)
var viewer = this.viewer;
viewer.updateToolbarButtons =  this.updateToolbarButtons(viewer);

Fonction dans l'autre objet.

updateToolbarButtons = function(viewer) {
  var _viewer = viewer;
  return function(width, height){ 
blah blah black sheep I can refer to this.anything();
}
};

Je ne sais pas si cela fonctionnera dans toutes les circonstances, mais dans notre cas, nous essayions de remplacer la describefonction dans Jest afin de pouvoir analyser le nom et ignorer tout le describebloc s'il répondait à certains critères.

Voici ce qui a fonctionné pour nous:

function describe( name, callback ) {
  if ( name.includes( "skip" ) )
    return this.describe.skip( name, callback );
  else
    return this.describe( name, callback );
}

Deux choses qui sont essentielles ici:

1. Nous n'utilisons pas de fonction fléchée () =>.

   Les fonctions fléchées changent la référence à thiset nous avons besoin que ce soit le fichier this.

2. L'utilisation de this.describeet this.describe.skipau lieu de juste describeet describe.skip.

Encore une fois, je ne suis pas sûr que cela ait de la valeur pour quiconque, mais nous avons initialement essayé de nous en sortir avec l' excellente réponse de Matthew Crumley, mais nous devions faire de notre méthode une fonction et accepter les paramètres afin de les analyser au conditionnel.