Javascript 向所有函数添加一行代码

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

---

您可以尝试以下方法，动态修改您的函数：

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

---

您可以尝试以下方法，动态修改您的函数：

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

---

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

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

---

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

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

---

最简单的方法是使用代理类。假设您的常规类是类A，代理类是类B。类B内部有一个类A的实例。类B还为调用其内部类a实例的每个类a函数都有一个存根。然后，只需在类A的函数调用之前或之后将代码添加到关联的存根中，就可以将任何代码添加到原始类中

---

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

最简单的方法是使用代理类。假设您的常规类是类A，代理类是类B。类B内部有一个类A的实例。类B还为调用其内部类a实例的每个类a函数都有一个存根。然后，只需在类A的函数调用之前或之后将代码添加到关联的存根中，就可以将任何代码添加到原始类中

---

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

我认为，您必须修改Coffeescript编译器才能做到这一点。这很重要，因为函数中可以包含

return

语句。我认为，要做到这一点，您必须修改Coffeescript编译器。这很重要，因为函数中可以有

return

语句；然而，his会自动转换您的函数，而我的函数则会显式转换。然而，您不需要对

参数进行
切片
，事件应该在函数和OP的
事件之后触发。fire
似乎是一个字符串，不是函数参数。公平点：）对于没有数组泛型的旧浏览器，参数不需要
slice
？只有当您需要它作为数组时-但是
apply
也需要纯
参数
对象。我的答案基本上与@Bergi的相同；然而，his会自动转换您的函数，而我的函数则会显式转换。然而，您不需要对
参数进行
切片
，事件应该在函数和OP的
事件之后触发。fire
似乎是一个字符串，不是函数参数。公平点：）对于没有数组泛型的旧浏览器，参数不需要
slice
？仅当您需要它作为数组时-但是
apply
也需要纯
参数
对象。现在尝试一下，效果很好。有没有办法让它成为一个超级类，而我的其他类继承它？所以我不必对我所有的类/对象都这样做？谢谢不可以。在为每个类（将其包装在函数中）将方法分配给原型对象后，必须显式执行此操作。顺便说一句，如果您使用的是继承，您可能还会添加一个
hasOwnProperty
检查。最后使用了这个选项，创建了一个github repo，其中的代码包括所有人都希望这样做的代码：现在尝试一下，效果很好。有没有办法让它成为一个超级类，而我的其他类继承它？所以我不必对我所有的类/对象都这样做？谢谢不可以。在为每个类（将其包装在函数中）将方法分配给原型对象后，必须显式执行此操作。顺便说一句，如果您使用的是继承，您可能还会添加一个
hasOwnProperty
检查。最后使用了这个选项，创建了一个github回购协议，其中的代码包括所有人都希望执行的代码：@QuintonPike:看起来有点像我的解决方案，只是你写一个新类的原型而不是覆盖所有内容。@QuintonPike：这看起来有点像我的解决方案，只是你写一个新类的原型而不是覆盖所有内容。