function test(arg1) {
    console.log(2);
    return arg1;
}

假设当前有一个 test 函数，我们需要测试 test 函数执行时消耗的时间，那么最先想到的做法是：

var start = new Date();
test("a");
var end = new Date();
console.log('spend:' + (end - start));

但如果需要测试更多的函数，我们就需要编写更多的 start、end，为了能通用的在函数前后执行某些操作，我们尝试引用面向切面编程（AOP）:

Function.prototype.before = function(fn){
    var __test = this;
    return function beforeClosure() {
        fn();
        return __test.apply(this, arguments);
    }
}
Function.prototype.after = function(fn){
    var __beforeClosure = this;
    return function afterClosure() {
        var result = __beforeClosure.apply(this, arguments);
        fn();
        return result;
    }
}

我们为 Function 原型链上添加 before 和 after 方法，然后调用，下面详细解析：

var _afterClosure = test.before(function() {
    console.log(1);
}).after(function() {
    console.log(3);
});
var result = _afterClosure('b');

1. 在 test.before 执行时，内部的 this 当前指向 test 函数，使用临时变量 __test 保存，方法返回一个闭包，为方便理解闭包命名为 beforeClosure 。

2. beforeClosure 被返回后， after 方法的调用变成了 beforeClosure.after，after
   内部 this 当前指向 beforeClosure，使用临时变量 __beforeClosure 保存，方法返回一个闭包，命名为 afterClosure。

3. 调用 _afterClosure('b')，afterClosure 内部首先调用 beforeClosure 闭包，并把当前 this 和 参数传入 beforeClosure。

4. beforeClosure 内部首先调用 before 参数中的方法 console.log(1) ，然后调用 test 方法，调用过程中的 this 和 arguments 都是 beforeClosure 调用时传进来的，与 afterClosure 是一致的。

5. beforeClosure 执行完毕，返回 test 的返回值，回到 afterClosure 的第一步，接收 test 函数的返回值到 result，然后执行 .after 参数中的函数 console.log(3)，
   最后把 result 返回，结束。

最后测试代码：

var start = 0;
var end = 0;
function startTime() {
    start = new Date();
}
function endTime() {
    end = new Date();
    console.log('spend: ' + (end - start));
}
test.before(startTime).after(endTime)('c');

假设有更多函数需要测试，我们只需要 func.before(startTime).after(endTime)() 调用即可。

当 after 与 before 调换顺序调用时，两个闭包的调用流程是翻转的，但该代码也可正确运行。