Technique de chaînage générique pour la méthode surchargée

Question

Une opération commune en JavaScript consiste à remplacer une méthode d'objet par un nouveau tout en appelant toujours la méthode d'origine.Ceci est souvent fait comme ceci:

var originalMethod = obj.method;
obj.method = function(arg) {
    // call original method
    originalMethod.call(this, arg);
    // do my stuff new stuff
}

J'aimerais créer une fonction utilitaire pour une méthode d'objet spécifique qui gère la partie enchaînant de sorte que l'utilisateur n'a pas besoin de s'inquiéter à ce sujet.Une option consiste à utiliser la conception ci-dessus, dans laquelle chaque fonction ajoutée est enveloppée dans une nouvelle fonction qui appelle la précédente.Une autre option consiste à créer une matrice de fonctions et à rendre la méthode d'objet simplement itérer sur la matrice, appelant chaque fonction à son tour.

function addXyzMethod1(fn) {
    if (obj.method) {
        var previousMethod = obj.method;
        obj.method = function(value) {
            value = previousMethod.call(this, value);
            return fn.call(this, value);
        };
    } else {
        obj.method = fn;
    }
}

function addXyzMethod2(fn) {
    if (obj._methodList) {
        obj._methodList.push(fn);
    } else if (obj.method) {
        obj._methodList = [obj.method, fn];
        obj.method = function(value) {
            for (var i = 0, n = obj._methodList.length; i < n; i++) {
                value = obj._methodList[i].call(this, value);
            }
            return value;
        };
    } else {
        obj.method = fn;
    }
}

À ce stade, je ne peux pas décider quelle méthode à utiliser depuis que je ressens les compromis de chacun de chacun de chacun.Donc, ma question ici est: laquelle de ces méthodes est meilleure (plus naturelle ou acceptée, ou plus rapide) ou existe une autre méthode qui s'améliore à la fois sur ces deux?

Answer 1

Cette question est assez similaire, ou du moins vient à une question similaire ici: https://stackoverflow.com/questions/660337 < / a>

lire la réponse préférée là-bas, je vous recommanderais de rester avec addxyzmethod1 si Vous savez que vous n'avez pas à écraser la fonction si souvent que vous rencontrez de manière si souvent que vous courez dans les dangers d'un débordement de pile.

Si vous voulez une solution alternative (qui serait souhaitable à mon avis), une meilleure compréhension de ce que vous essayez de faire exactement l'utilité. Je n'ai pas obligé cette technique depuis longtemps et de mon expérience c'est une mauvaise pratique dans la plupart des cas. Il y a des modèles de conception qui vous aident à éviter cette situation. Par exemple. Utilisez la composition. Avoir un objet représentant une collection de fonctions (peut être un tableau simple de fonctions) et injecter celui-ci dans votre objet via son constructeur et stockez-le en tant que membre. Ensuite, utilisez-le dans cette méthode que vous vouliez à l'origine remplacer. La collection que vous avez injectée, vous pouvez toujours ajouter et supprimer des fonctions. Ce serait un peu similaire à votre addxyzmethod2 sans avoir à cette fonction UTIL globale et sans la nécessité d'écraser la méthode d'origine de votre objet.

Answer 2

What you are trying to do is a JavaScript version of call super, which is described as a code smell by Martin Fowler.

I would suggest instead that you either

1. Contain the "super" object instead of inheriting from it.

2. Use template method, such as below

   templateMethod = function () {
        baseMethod();
        if (overrideMethod) {
             overrideMethod();
        }
   };
   

Other objects would call templateMethod. The overrideMethod is where child objects would have their code.