Question

所以我在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');
}

Answer 1

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

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]);

Answer 2

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

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));

Answer 3

最简单的方法是拥有一个代理类。假设您的常规类是A类，代理类是B类.B类内部有一个A类实例。对于每个将其内部类调用为实例的A类函数，B类也有一个存根。然后，您可以通过简单地将代码添加到关联的存根 - 在函数调用A类之前或之后，将所需的任何代码添加到原始类中。

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

为所有函数添加一行代码

3 个答案: