Hooks de fonctions Javascript

Peut-être pas assez, mais il semble fonctionner...

<script>

function A(x) { alert(x); return x; }
function B() { alert(123); }

function addHook(functionB, functionA, parent)
{
    if (typeof parent == 'undefined')
        parent = window;

    for (var i in parent)
    {
        if (parent[i] === functionA)
        {
            parent[i] = function()
            {
                functionB();
                return functionA.apply(this, arguments)
            }

            break;
        }
    }
}

addHook(B, A);

A(2);

</script>

réponse Très simple:

function someFunction() { alert("Bar!") }
var placeholder=someFunction;
someFunction=function() {
  alert("Foo?");
  placeholder();
}

Cette réponse n'est pas définitive, mais plutôt de démonstration d'une technique différente que ceux proposés jusqu'à présent. Cela tient compte du fait qu'une fonction en Javascript est un objet de première classe, et en tant que tel, a) vous pouvez la passer comme valeur à une autre fonction et b) vous pouvez y ajouter des propriétés. Combinez ces caractéristiques avec les méthodes "call" (ou "apply") intégrées à la fonction, et vous avez vous-même un début vers une solution.

var function_itself = function() {
    alert('in function itself');
}
function_itself.PRE_PROCESS = function() {
    alert('in pre_process');
}
function_itself.POST_PROCESS = function() {
    alert('in post_process');
}

var function_processor = function(func) {
    if (func.PRE_PROCESS) {
        func.PRE_PROCESS.call();
    }
    func.call();
    if (func.POST_PROCESS) {
        func.POST_PROCESS.call();
    }        
}

La fonction suivante vous donnera avant et après les crochets qui peuvent être empilés. Donc, si vous avez un certain nombre de fonctions qui ont besoin de courir avant la fonction donnée ou après la fonction donnée alors ce serait une solution de travail. Cette solution ne nécessite pas de jQuery et utilise des méthodes natives array (pas de shims requis). Il devrait aussi être sensible au contexte donc si vous appelez la fonction originale avec un contexte Si devrait exécuter chaque fonction avant et après pareillement.

// usage: 
/*
function test(x) {
    alert(x);
}

var htest = hookable(test);

htest.addHook("before", function (x) {
    alert("Before " + x);
})
htest.addHook("after", function (x) {
    alert("After " + x);
})

htest("test") // => Before test ... test ... After test
*/
function hookable(fn) {
    var ifn = fn,
        hooks = {
            before : [],
            after : []
        };

    function hookableFunction() {
        var args = [].slice.call(arguments, 0),
            i = 0,
            fn;
        for (i = 0; !!hooks.before[i]; i += 1) {
            fn = hooks.before[i];
            fn.apply(this, args);
        }
        ifn.apply(this, arguments);
        for (i = 0; !!hooks.after[i]; i++) {
            fn = hooks.after[i];
            fn.apply(this, args);
        }
    }

    hookableFunction.addHook = function (type, fn) {
        if (hooks[type] instanceof Array) {
            hooks[type].push(fn);
        } else {
            throw (function () {
                var e = new Error("Invalid hook type");
                e.expected = Object.keys(hooks);
                e.got = type;
                return e;
            }());
        }
    };

    return hookableFunction;
}

Voici ce que j'ai fait, pourrait être utile dans d'autres applications comme ceci:

//Setup a hooking object
a={
    hook:function(name,f){
        aion.hooks[name]=f;
    }
}a.hooks={
    //default hooks (also sets the object)
}; 

//Add a hook
a.hook('test',function(){
    alert('test');
});

//Apply each Hook (can be done with for)
$.each(a.hooks,function(index,f){
    f();
});

je ne sais pas si ce sera utile. Vous avez besoin de modifier la fonction originale mais seulement une fois et vous n'avez pas besoin de continuer à l'éditer pour tirer des crochets

https://github.com/rcorp/hooker