0

所以我在 JS 中工作了很多，并且我在事件上工作了很多（尽量保持模块化）。当前我Event.fire('eventName')在每个函数结束时调用。我正在寻找一种方法让我的对象/类中的任何函数在Event.fire([function name])所有函数的末尾自动调用

例子：

function MyClass(){
   this.on('someFunc', this.funcTwo);
   this.someFunc();
}
MyClass.prototype.on = function( event ){
   // the event stuff //
}
MyClass.prototype.someFunc = function(){
   console.log('someFunc');
}
MyClass.prototype.funcTwo = function(){
   console.log('funcTwo');
}
4

3 回答 3

5

您可以尝试这样的事情，动态修改您的功能：

var obj = MyClass.prototype;
for (var prop in obj)
    if (typeof obj[prop] == "function") // maybe also prop != "on" and similar
        (function(name, old) {
            obj[prop] = function() {
                var res = old.apply(this, arguments);
                Event.fire(name);
                return res;
            };
        })(prop, obj[prop]);
于 2013-03-25T15:15:18.027 回答
1

您可以创建一个函数来构建始终具有该功能的函数：

var eventFunctionFactory = function(fn, e) {
  if (typeof fn != 'function' || typeof e != 'function') {
    throw new TypeError('Invalid function!');
  }

  return function(/* arguments */) {
    // Convert arguments to array
    var args = Array.prototype.slice.call(arguments);

    // Fire event
    Event.fire(e);

    // Call the function with the applied arguments
    // Return its result
    return fn.apply(fn, args);
  };
};

var myClass = function() {
  this.someFunction = eventFunctionFactory(
                        // Function
                        function(a, b) {
                          return a + b;
                        },

                        // Event
                        function() {
                          console.log('someFunction fired!');
                        }
                      );
};

var myObj = new myClass();

// Outputs:
// someFunction fired!
// 3
console.log(myObj.someFunction(1, 2));
于 2013-03-25T15:22:43.927 回答
0

最简单的方法是拥有一个代理类。假设您的常规类是 A 类，代理类是 B 类。B 类在内部有一个 A 类的实例。B 类还为每个 A 类函数都有一个存根，该函数将其内部类称为实例。然后，您可以通过简单地将代码添加到关联的存根（在对类 A 的函数调用之前或之后）将任何您想要的代码添加到原始类。

为了能够使用增强的类，您需要做的就是修改应用程序的其余部分以实例化 B 类而不是 A 类。这种方法的优点是您的原始类保持不变。

于 2013-03-25T15:40:36.923 回答