Fonction crochets Javascript

EDIT: OK, je crois que les solutions suivantes sont valides:

Utiliser le jQuery AOP plugin. Essentiellement, il enveloppe le vieux de la fonction en collaboration avec le crochet dans une fonction sandwich et réassigne à l'ancien nom de la fonction. Cela provoque l'imbrication de fonctions avec chaque nouveau crochet.
Si jQuery n'est pas utilisable pour vous, il suffit de le pillage du code source, il ne semble pas y avoir de jQuery dépendances dans le plugin, et la source est simple et très petite.
Ont un objet décrivant tous les crochets et leurs objectifs, et de stocker le initiale non modifiée de la fonction. Lors de l'ajout d'un nouveau raccordement, de l'emballage à refaire autour de la fonction d'origine, au lieu de ré-enrouler le précédent habillage de la fonction.
De vous échapper de fonctions imbriquées, et obtenir deux objets à manipuler à la place. Potentiellement, cela pourrait également signifier plus facile crochet de manutention, si vous ajoutez/supprimez les crochets souvent et de commande.

Je vais aller avec le premier, puisque c'est déjà fait, et je n'ai pas de performance à s'inquiéter. Et depuis que les fonctions ne sont pas affectées, même si je passe accrochage méthodes, je vais seulement besoin de refaire le crochet en ajoutant, ce qui pourrait être juste une simple recherche&remplacer des opérations.

Salut,

Est-il possible de créer un mécanisme, dans lequel la fonction A aurait pu avoir un jeu de crochets(les fonctions à exécuter avant/après de la fonction A)?

Idéalement, la fonction ne serait pas conscient de l'accrochage de la fonctionnalité, de sorte que je n'ai pas à modifier le code source de la fonction à appeler les crochets. Quelque chose comme:

A = function(){
    alert("I'm a naive function");
};
B = function(){
    alert("I'm having a piggyback ride on function A!"+
          "And the fool doesn't even know it!");
};
addHook(B, A)//add hook B to function A
A()
//getting alerts "I'm a naive function"/"I'm having a 
//piggyback ride on function A! And the fool doesn't even know it!"

J'ai essayé de pirater quelque chose pour un couple d'heures, mais jusqu'à présent aucune chance.

source d'informationauteur Seyen

10

Prendre un coup d'oeil à jQuery plugin AOP. En général, google "javascript aspect oriented programming".

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. Il exploite le fait qu'une fonction en Javascript est un de première classe de l'objet, et en tant que tel, un), vous pouvez passer en tant que valeur à une autre fonction, et b) vous pouvez ajouter des propriétés. Combiner ces traits de caractère avec la fonction intégrée dans le "call" (ou "appliquer") des méthodes, 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 utilisant les méthodes de tableau (pas de cales nécessaires). Il doit également être sensible au contexte, donc si vous êtes à l'appel de la fonction originale avec un contexte si devez exécuter chaque avant et après la fonction de la même manière.

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

0

Je ne sais pas si ce sera utile. Vous avez besoin de modifier la fonction d'origine, mais une seule fois et vous n'avez pas à garder à l'éditer pour la cuisson de crochets

https://github.com/rcorp/hooker

Vous devez vous connecter pour publier un commentaire.