Tecnica di catena generica per il metodo sovraccarico

Question

Un'operazione comune in JavaScript è quella di sostituire un metodo oggetto con uno nuovo mentre chiamano ancora il metodo originale.Questo è spesso fatto così:

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

.

Mi piacerebbe creare una funzione di utilità per un metodo specifico dell'oggetto che gestisce la parte della catena in modo che l'utente non abbia bisogno di preoccuparsi.Un'opzione è quella di utilizzare il design sopra riportato, in cui ogni funzione aggiunta è avvolta in una nuova funzione che chiama il precedente.Un'altra opzione è quella di creare una serie di funzioni e rendere il metodo dell'oggetto solo in iterato sopra l'array, chiamando ogni funzione a turno.

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

.

A questo punto, non riesco a decidere quale metodo utilizzare da quando sento che i trade-off di ciascuno riguardano anche.Quindi la mia domanda qui è: quale di questi metodi è migliore (più naturale, o accettato o più rapido) o c'è un altro metodo che migliora su entrambi questi?

Answer 1

Questa domanda è abbastanza simile, o almeno si riduce a una domanda simile qui: https://stackoverflow.com/questions/660337 < / a>

Leggere la risposta preferita lì, ti consiglierei di attaccare con addxyzmethod1 se sai che non devi sovrascrivere la funzione così spesso che stai eseguendo I pericoli di uno stack overflow.

Se si desidera una soluzione alternativa (che sarebbe auspicabile secondo me), una migliore comprensione su ciò che stai cercando di fare esattamente sarebbe utile. Non ho richiesto questa tecnica da molto tempo e dalla mia esperienza questa è una brutta pratica nella maggior parte dei casi. Ci sono pastiglie di design che ti aiutano a evitare questa situazione. Per esempio. Usa la composizione. Avere un oggetto che rappresenta una raccolta di funzioni (può essere una semplice matrice di funzioni) e iniettare quella nel tuo oggetto tramite il suo costruttore e conservarlo come membro. Quindi usalo in quel metodo che hai dovuto sostituire. La raccolta che hai iniettato, puoi ancora aggiungere e rimuovere le funzioni da esso. Questo sarebbe un po 'simile al tuo addxyzmethod2 solo senza avere quella funzione Global Util e senza la necessità di sovrascrivere il metodo originale del tuo oggetto.

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.