tecnica di concatenamento generico per il metodo sovraccarico

Question

tecnica di concatenamento generico per il metodo sovraccarico

#1 da (1 voti)
#2 da (1 voti)

2

Un'operazione comune in JavaScript è quella di sostituire un metodo oggetto con uno nuovo mentre si chiama ancora il metodo originale. Questo è spesso fatto in questo modo:

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 oggetto specifico che gestisca la parte concatenata in modo che l'utente non debba preoccuparsi di ciò. Un'opzione consiste nell'usare il disegno sopra, in cui ogni funzione aggiunta è racchiusa in una nuova funzione che chiama quella precedente. Un'altra opzione è creare una serie di funzioni e rendere il metodo object semplicemente iterato sull'array, chiamando a turno ciascuna funzione.

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 posso decidere quale metodo utilizzare poiché ritengo che i compromessi di ciascuno siano pari. Quindi la mia domanda qui è: quale di questi metodi è migliore (più naturale, accettato o più veloce) o c'è un altro metodo che migliora su entrambi?

javascript extensibility

posta Michael Best 11.07.2013 - 23:48

fonte

2 risposte

1

Quello che stai cercando di fare è una versione JavaScript di call super, che è descritta come un odore di codice di Martin Fowler .

Suggerisco invece di scegliere

Contiene l'oggetto "super" invece di ereditare da esso.

Utilizza il metodo del modello, come di seguito

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

Altri oggetti chiamerebbero templateMethod. L'overrideMethod è dove gli oggetti figlio avrebbero il loro codice.

risposta data 15.07.2013 - 23:22

fonte

Leggi altre domande sui tag javascript extensibility

Uso della libreria LGPL con collegamento statico o dinamico Java Utilizzare ILmerge per le librerie NuGet?

score 1 · Accepted Answer

Questa domanda è abbastanza simile, o almeno si riferisce a una domanda simile qui: link

Leggendo la risposta preferita lì, ti consiglierei di rimanere con addXyzMethod1 se sai che non devi sovrascrivere la funzione così spesso che ti imbatti in i pericoli di uno stack overflow.

Se vuoi una soluzione alternativa (che sarebbe auspicabile, a mio parere), sarebbe utile una migliore comprensione di ciò che stai cercando di fare esattamente. Non ho richiesto questa tecnica da molto tempo e dalla mia esperienza questa è una cattiva pratica nella maggior parte dei casi. Ci sono schemi di progettazione 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 serie di funzioni) e iniettarlo nell'oggetto tramite il suo costruttore e memorizzarlo come membro. Quindi utilizzalo in quel metodo che avevi originariamente voluto sostituire. La raccolta che hai iniettato, puoi ancora aggiungere e rimuovere funzioni da essa. Questo sarebbe un po 'simile al tuo addXyzMethod2 semplicemente senza avere quella funzione di utilità globale e senza la necessità di sovrascrivere il metodo originale dell'oggetto.