用Javascript包裝一個函數/ jQuery

Question

如果我有一個任意的函數myFunc，我打算做的是用一個在其執行前後運行代碼的包裝函數替換這個函數。

// note: psuedo-javascript 

var beforeExecute = function() { ... } 
var afterExecute = function() { ... } 

myFunc = wrap(myFunc, beforeExecute, afterExecute); 

但是，我沒有執行所需的wrap函數。這樣的jQuery中是否存在任何已存在的東西（我已經通過文檔瞭解了很多，但看不到任何東西）？或者，任何人都知道這一點很好的實現，因爲我懷疑，如果我自己寫這些，我會懷念一些邊緣案例嗎？ （這是因爲我們在封閉設備上做了很多工作，其中Javascript分析器等不可用，所以我需要做一些自動的函數檢測工作，如果有更好的方法，那麼我會很感激沿着這些線路的答案太）

Answer 1

這裏是一個wrap功能，將調用before和after功能完全相同的參數和，如果提供，用於this相同的值：

var wrap = function (functionToWrap, before, after, thisObject) { 
    return function() { 
     var args = Array.prototype.slice.call(arguments), 
      result; 
     if (before) before.apply(thisObject || this, args); 
     result = functionToWrap.apply(thisObject || this, args); 
     if (after) after.apply(thisObject || this, args); 
     return result; 
    }; 
}; 

myFunc = wrap(myFunc, beforeExecute, afterExecute); 

Answer 2

你可以這樣做：

var wrap = function(func, pre, post) 
{ 
    return function() 
    { 
    var callee = arguments.callee; 
    var args = arguments; 

    pre();  
    func.apply(callee, args);  
    post(); 
    }; 
}; 

這將允許你這樣做：

var someFunc = function(arg1, arg2) 
{ 
    console.log(arg1); 
    console.log(arg2); 
}; 

someFunc = wrap(
    someFunc, 
    function() { console.log("pre"); }, 
    function() { console.log("post"); }); 

someFunc("Hello", 27); 

其中給出我在Firebug的輸出：

pre 
Hello 
27 
post 

的重要組成部分，包裝這樣的情況下，從新功能傳遞你的論點回到原來的功能。

Answer 3

這是我會用例子

<script type="text/javascript"> 
    var before = function(){alert("before")}; 
    var after = function(param){alert(param)}; 
    var wrap = function(func, wrap_before, wrap_after){ 
    wrap_before.call(); 
    func.call(); 
    wrap_after.call(); 
    }; 
    wrap(function(){alert("in the middle");},before,function(){after("after")}); 
</script> 

Answer 4

也許我錯了，但我認爲你可以直接創建一個化名功能，並將其分配給myFunc的：

 
myFunc = function(){ 
      BeforeFunction(); 
      myFunc(); 
      AfterFunction(); 
     } 

這樣你可以控制每個函數的參數。

Answer 5

接受的實現不提供一個選項，以有條件地調用包裝（原始）功能。

這裏是一個更好的方式來包裝和解開的方法：

/* 
    Replaces sMethodName method of oContext with a function which calls the wrapper 
    with it's list of parameters prepended by a reference to wrapped (original) function. 

    This provides convenience of allowing conditional calls of the 
    original function within the wrapper, 

    unlike a common implementation that supplies "before" and "after" 
    cross cutting concerns as two separate methods. 

    wrap() stores a reference to original (unwrapped) function for 
    subsequent unwrap() calls. 

    Example: 
    ========================================= 

    var o = { 
     test: function(sText) { return sText; } 
    } 

    wrap('test', o, function(fOriginal, sText) { 
     return 'before ' + fOriginal(sText) + ' after'; 
    }); 
    o.test('mytext') // returns: "before mytext after" 

    unwrap('test', o); 
    o.test('mytext') // returns: "mytext" 

    ========================================= 
*/ 
function wrap(sMethodName, oContext, fWrapper, oWrapperContext) { 
    var fOriginal = oContext[sMethodName]; 

    oContext[sMethodName] = function() { 
     var a = Array.prototype.slice.call(arguments); 
     a.unshift(fOriginal.bind(oContext)); 
     return fWrapper.apply(oWrapperContext || oContext, a); 
    }; 
    oContext[sMethodName].unwrapped = fOriginal; 
}; 

/* 
    Reverts method sMethodName of oContext to reference original function, 
    the way it was before wrap() call 
*/ 
function unwrap(sMethodName, oContext) { 
    if (typeof oContext[sMethodName] == 'function') { 
     oContext[sMethodName] = oContext[sMethodName].unwrapped; 
    } 
};