AOP(Aspect Oriented Programming,面向切面編程)的核心想法是:把日誌、權限、效能統計這類「與主流程無直接關係但到處都需要」的邏輯抽離出來,在目標函式前後統一掛上,而不必侵入原本的方法內容。JavaScript 因為函式是一等公民,實作 AOP 相對輕鬆。
這個模組提供 aop({ options }) 一支函式,接受幾個設定:
context:目標函式所處的執行範圍,不給就預設 window。target:要攔住的方法名稱,可以是字串或函式本身。before:在目標方法之前執行的函式。after:在目標方法之後執行的函式。around:包圍目標方法,前後各跑一次。var aop = (function () {
var options = {}, context = window,
oFn, oFnArg, targetFn, targetFnSelector,
beforeFn, afterFn, aroundFn;
// 複製原函式,避免無限遞迴
var cloneFn = function (Fn) {
if (typeof Fn === "function") {
return eval('[' + Fn.toString() + ']')[0];
}
return null;
};
var checkContext = function () {
if (options.context) { context = options.context; }
if (typeof context[(options.target).name] === "function") {
targetFnSelector = (options.target).name;
targetFn = context[targetFnSelector];
} else if (typeof context[options.target] === "function") {
targetFnSelector = options.target;
targetFn = context[targetFnSelector];
}
if (targetFn) {
oFn = cloneFn(targetFn);
oFnArg = new Array(targetFn.length);
return true;
}
return false;
};
var run = function () {
context[targetFnSelector] = function (oFnArg) {
if (aroundFn) { aroundFn.apply(this, arguments); }
if (beforeFn) { beforeFn.apply(this, arguments); }
oFn.apply(this, arguments);
if (afterFn) { afterFn.apply(this, arguments); }
if (aroundFn) { aroundFn.apply(this, arguments); }
};
};
return function (opt) {
if (opt && typeof opt === "object" && !opt.length) {
options = opt;
if (options.target && checkContext()) {
if (options.before && typeof options.before === "function") { beforeFn = options.before; }
if (options.after && typeof options.after === "function") { afterFn = options.after; }
if (options.around && typeof options.around === "function") { aroundFn = options.around; }
run();
}
}
};
}());
最關鍵的一步是 cloneFn:如果直接把原本的 targetFn 放進新的包裹函式裡呼叫,其實是沒問題的;但一旦我們用 context[name] = 新函式 覆寫了它,後續任何取得該名稱的途徑都會拿到包裹版,因此必須先保留一份原始函式的參照。這裡用 eval 搭配 toString() 達到「複製」的效果,雖然直覺,卻也是最需要小心的地方(後文會提到)。
function test(name, age) {
console.log("test fn. name = " + name + " age: " + age);
}
aop({
target: "test",
before: function () { console.log("aop before"); },
after: function () { console.log("aop after"); },
around: function () { console.log("aop around"); }
});
test("adam", 6);
var myobj = {
myName: "testName",
sayName: function () { console.log(this.myName); },
childObj: {
age: 6,
say: function () { console.log(this.age); }
}
};
aop({
context: myobj,
target: "sayName",
before: function () { console.log("aop before say name = " + this.myName); },
after: function () { console.log("aop after say name = " + this.myName); },
around: function () { console.log("aop around say name = " + this.myName); }
});
myobj.sayName();
aop({
context: myobj.childObj,
target: "say",
before: function () { console.log("aop before age = " + this.age); },
after: function () { console.log("aop after age = " + this.age); },
around: function () { console.log("aop around age = " + this.age); }
});
myobj.childObj.say();
注意所有 before / after / around 都是用 apply(this, arguments) 呼叫,因此裡面的 this 會正確指向呼叫者,能直接讀到 this.myName、this.age 這類同物件上的屬性。
cloneFn 依賴 eval(Fn.toString()),在採用 Content Security Policy 的環境會直接失效,對閉包也無能為力。更穩妥的寫法是先把原函式存進區域變數:var original = context[name]; context[name] = function () { ...; return original.apply(this, arguments); }。around 在目標前後各執行一次,等同於「before + after」,與常見 AOP 框架中「一個函式決定何時 proceed()」的語意不同,使用時要特別留意。options.around 的判斷原本誤寫成檢查 options.after,本文已修正為檢查 options.around。儘管如此,這個範例把 AOP 的精神示範得很清楚:用高階函式包住原函式,在呼叫的前後插入通用邏輯,主流程的原始碼一行都不用改。