Anular una función de JavaScript al hacer referencia al original

Tengo una función, a()que quiero anular, pero también tengo que realizar el original a()en un orden dependiendo del contexto. Por ejemplo, a veces, cuando estoy generando una página, quiero anular así:

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

y a veces así:

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

¿Cómo consigo eso original_a()desde dentro de la anulación a()? ¿Es posible?

Por favor, no sugiera alternativas para anular de esta manera, conozco muchas. Estoy preguntando sobre esta manera específicamente.

Podrías hacer algo como esto:

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

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

Declarar original_adentro de una función anónima evita que satura el espacio de nombres global, pero está disponible en las funciones internas.

Como Nerdmaster mencionó en los comentarios, asegúrese de incluir el ()al final. Desea llamar a la función externa y almacenar el resultado (una de las dos funciones internas) en a, no almacenar la función externa en sí a.

El patrón Proxy podría ayudarte:

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

Lo anterior envuelve su código en una función para ocultar la variable "proxy". Guarda el método setArray de jQuery en un cierre y lo sobrescribe. Luego, el proxy registra todas las llamadas al método y delega la llamada al original. El uso de apply (esto, argumentos) garantiza que la persona que llama no podrá notar la diferencia entre el método original y el proxy.

Gracias a todos, el patrón proxy realmente ayudó ... En realidad, quería llamar a una función global foo ... En ciertas páginas necesito hacer algunas comprobaciones. Entonces hice lo siguiente.

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

Gracias, esto realmente me ayudó

Puede anular una función usando una construcción como:

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

Por ejemplo:

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

Editar: se corrigió un error tipográfico.

Pasar argumentos arbitrarios:

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 respuesta que proporciona @Matthew Crumley es hacer uso de las expresiones de función invocadas inmediatamente, para cerrar la función 'a' anterior en el contexto de ejecución de la función devuelta. Creo que esta fue la mejor respuesta, pero personalmente, preferiría pasar la función 'a' como argumento a IIFE. Creo que es más comprensible.

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

Los ejemplos anteriores no se aplican thiso pasan argumentscorrectamente a la función de anulación. El subrayado _.wrap () ajusta las funciones existentes, aplica thisy pasa argumentscorrectamente. Ver: http://underscorejs.org/#wrap

Tenía otro código escrito por otra persona y quería agregar una línea a una función que no pude encontrar en el código. Entonces, como solución, quería anularlo.

Sin embargo, ninguna de las soluciones funcionó para mí.

Esto es lo que funcionó en mi caso:

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

He creado un pequeño ayudante para un escenario similar porque a menudo necesitaba anular funciones de varias bibliotecas. Este asistente acepta un "espacio de nombres" (el contenedor de funciones), el nombre de la función y la función de anulación. Reemplazará la función original en el espacio de nombres referido con la nueva.

La nueva función acepta la función original como primer argumento y los argumentos de las funciones originales como el resto. Preservará el contexto cada vez. También admite funciones nulas y no nulas.

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

Uso, por ejemplo, con Bootstrap:

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

Sin embargo, no creé ninguna prueba de rendimiento. Posiblemente puede agregar una sobrecarga no deseada que puede o no ser un gran problema, dependiendo de los escenarios.

En mi opinión, las respuestas principales no son legibles / mantenibles, y las otras respuestas no vinculan adecuadamente el contexto. Aquí hay una solución legible que usa la sintaxis ES6 para resolver estos dos problemas.

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

Entonces mi respuesta terminó siendo una solución que me permite usar la variable _esta variable apuntando al objeto original. Creo una nueva instancia de un "Cuadrado", pero odiaba la forma en que el "Cuadrado" generaba su tamaño. Pensé que debería seguir mis necesidades específicas. Sin embargo, para hacerlo, necesitaba que el cuadrado tuviera una función "GetSize" actualizada con las funciones internas de esa función que llama a otras funciones que ya existen en el cuadrado, como this.height, this.GetVolume (). Pero para hacerlo, necesitaba hacerlo sin ningún truco loco. Entonces aquí está mi solución.

Alguna otra inicializador de objetos o función auxiliar.

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

Función en el otro objeto.

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

No estoy seguro de si funcionará en todas las circunstancias, pero en nuestro caso, intentamos anular la describefunción en Jest para poder analizar el nombre y omitir todo el describebloque si cumple con algunos criterios.

Esto es lo que funcionó para nosotros:

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

Dos cosas que son críticas aquí:

1. No usamos una función de flecha () =>.

   Las funciones de flecha cambian la referencia a thisy necesitamos que sea el archivo this.

2. El uso de this.describey en this.describe.skiplugar de just describey describe.skip.

Una vez más, no estoy seguro de que sea valioso para nadie, pero originalmente intentamos escapar con la excelente respuesta de Matthew Crumley, pero necesitábamos hacer que nuestro método funcionara y aceptar parámetros para analizarlos en condicional.