JavaScript之前（）和之后（）过滤器的Ruby样式

Question

有没有方法在Javascript中调用函数调用之前和之后？我有这样的事情：

var A = { 

    a1: function() { 

    }, 
}; 

var B = { 

    b1: function() { 

    } 
}; 

A.a1(); 
B.b1(); 
//so on .. 

我需要在每种方法之前和之后发生的事情。我可以在函数前后分别调用它们，但是我必须在代码中经常这样做，并且不想重复自己。

更新： 在红宝石

before_filter :some_function 
after_filter :some_other_function 

将每个函数调用之后，这些类和some_other_function每个函数调用之前执行some_function。这在Rails的应用程序控制器中也找不到。

Answer 1

试试这个改变对象的所有功能：

var beforeAll = function(o, f) { 
    for (var p in o) { 
    if (o.hasOwnProperty(p) && typeof(o[p]) === "function") { 
     o[p] = (function(oldF) { 
     return function() { 
      f.apply(this, arguments); 
      return oldF.apply(this, arguments); 
     }; 
     }(o[p])); 
    } 
    } 
}; 

var A = { 
    func1: function() {console.log('func1')}, 
    func2: function() {console.log('func2')} 
}; 

beforeAll(A, function() {console.log('before')}); 

A.func1(); 
A.func2(); 

（您可以创建一个类似的afterAll）。

小提琴here。

请注意，您需要捕获循环中的旧函数将其正确绑定。更多信息here。

Answer 2

如果保存的原单功能之后（或之前）调用它：

var A = { 

    a1: function() { 

    } 
}; 

var orginal = A.a1 
A.a1 = function(){ 
    // the before code 
    orginal.apply(this, arguments) 
} 

所有道具

for(prop in A){ 
    var orginal = prop 
    A[prop] = function(){ 
    //before code 
    orginal.apply(this, arguments) 
    } 
} 

我离开类型检查作为读者的傩： ）

Answer 3

您可以编写一个枚举对象的字段并将其函数封装为新函数的函数：

function addBefore(obj, func) { 
    for (var prop in obj) { 
     if (obj.hasOwnProperty(prop) && typeof obj[prop] === 'function') { 
      (function() { 
       var oldFunc = obj[prop]; 
       obj[prop] = function() { 
        func.apply(obj, arguments); 
        return oldFunc.apply(obj, arguments);    
       } 
      }()); 
     } 
    } 
} 
var A = { 

    a1: function (a, b) { 
    alert('A.a1'); 
    return a + b; 
    }, 
    a2: function (a, b) { 
    alert('A.a2'); 
    return a + b; 
    } 
}; 
addBefore(A, function (a, b) { 
    alert('before ' + a + ', ' + b); 
}); 
A.a1(1, 2); 
A.a2(3, 4); 

以类似的方式，您可以编写函数addAfter，只需将两个调用切换到apply（）函数即可。

Answer 4

在JavaScript中，约定是使用回调这种事情。所以，如果你想只陆续解雇一个功能，它会是这个样子：

var a1 = function(callback){ 
    console.log('doing function things la la'); 
    callback(); 
} 

现在，当你调用a1功能，你会做这样的事情：

a1(function(){ 
    console.log('this is only printed at the end!'); 
}); 

我想，你可以在函数中添加第二个参数，在我猜测之前，这个函数更像是一个call，但是你不会经常看到这个参数。

如果你正在讨论的是在大量没有回调的方法之前让某个函数运行，我认为最好的方法就是用一个接受你的主函数作为函数的函数来包装它们回调，这样的事情：

var a1 = function(){ console.log('a1'); } 
var a2 = function(){ console.log('a2'); } 
var a3 = function(){ console.log('a3'); } 
var a4 = function(){ console.log('a4'); } 

var before_filter = function(callback){ 
    console.log('doing some stuff before whoo!'); 
    callback(); 
} 

[a1, a2, a3, a4].map(function(fn){ 
    before_filter(fn); 
}); 

让我知道这是不是你以后有什么，我很乐意添加更多选项 - 有来处理这个问题许多潜在的方式，它只是取决于你究竟在寻找什么。将它做成像ruby一样干净是很困难的，因为before_filters本身并没有内置到JavaScript中，但是看看最后一个例子，你可以看到它很容易让它变得非常接近。一个比较另类类似于上一个：

var a1 = function(){ console.log('a1'); } 
var a2 = function(){ console.log('a2'); } 
var a3 = function(){ console.log('a3'); } 
var a4 = function(){ console.log('a4'); } 
var before = function(){ console.log('doing before stuff'); } 

var before_filter = function(before_fn, fn){ 
    before_fn(); 
    fn(); 
} 

[a1, a2, a3, a4].map(function(fn){ 
    before_filter(before, fn); 
});