AOP 的三種通知裡,around(環繞)最強大也最難寫對——它同時掌握原函式的前後,還能決定要不要呼叫它、能呼叫幾次、能帶什麼參數。本文從最直覺的寫法開始,一步步補上它缺少的每個環節。
最容易被想到的做法是把原函式當參數傳進來,在它前後插入程式:
const advice = function (originalFunc) {
console.log('before');
originalFunc();
console.log('after');
};
const obj = { foo: function () { console.log('foo'); } };
advice(obj.foo);
輸出順序正確。但這只是「執行了一次」,obj.foo 本身完全沒被改變,下次呼叫仍然只是乾巴巴的 foo。這不叫環繞。
要讓 obj.foo 真的被換掉,advice 必須回傳一個函式:
const advice = originalFunc => function () {
console.log('before');
originalFunc();
console.log('after');
};
const obj = {
foo: function () { console.log(this.name); },
name: 'obj'
};
obj.foo = advice(obj.foo);
obj.foo();
這次輸出是 before、空行、after——this.name 變成 undefined 了。因為新函式被呼叫時 this 是 obj 沒錯,但我們在閉包裡呼叫 originalFunc() 時並沒有指定它的 this,於是它掉進了全域。
直覺解法是用 call 把 this 補回去:
obj.foo = advice(function () {
return obj.foo.call(obj); // 想呼叫「原本那個」
});
結果直接爆 stack。原因很單純:obj.foo 此時已經是包裝後的新函式,你在閉包裡再呼叫它,就會無限遞迴。這是最經典的錯誤——必須先保留原始函式的參照。
const exist = obj.foo; // 先抓住原函式
obj.foo = advice(function () {
return exist.call(obj); // 呼叫保留下來的參照
});
obj.foo(); // before / obj / after
終於對了。但這一整套要手寫,每包一個函式就要重來一遍,太笨重。把它抽成通用函式:
function around(obj, prop, advice) {
const exist = obj[prop];
obj[prop] = advice(function () {
return exist.apply(obj, arguments);
});
}
const obj = {
foo: function () { console.log(this.name); },
name: 'obj'
};
around(obj, 'foo', originalFunc => function () {
console.log('before');
originalFunc();
console.log('after');
});
obj.foo(); // before / obj / after
around 把「處理流程」與「具體物件」解耦,advice 只要照固定格式書寫即可。這正是 dojo/aspect 與 YUI3 的核心手法。
如果同一個方法被包了兩次,你會需要ability把它們逐一拆掉,就像綁定/移除事件那樣。因此 around 應該回傳一個帶有 remove() 的 handle。
直覺寫法是「把 obj[prop] 設回 exist」,但這裡有個陷阱:如果先包了 A 再包 B,此時 obj.foo 是 B,而 B 的 exist 是 A。呼叫 A.remove() 若直接覆寫 obj.foo,就會把 B 也一起弄不見。正確做法是在包裝函式內部用一個開關,決定要繼續走 advised 還是退回 previous:
function around(obj, prop, advice) {
const exist = obj[prop];
const previous = function () {
return exist.apply(obj, arguments);
};
const advised = advice(previous);
obj[prop] = function () {
// advised 被設為 null 時,代表已解除,直接走上一層
return advised
? advised.apply(obj, arguments)
: previous.apply(obj, arguments);
};
return {
remove: function () {
advised = null;
advice = null;
// 注意:previous / exist / obj 不可清空,
// 否則解除後就再也無法退回原函式
}
};
}
測試一下雙重包裝與逐一解除:
let count = 1;
const countingAdvice = original => function () {
const current = count++;
console.log('before ' + current);
original.apply(this, arguments);
console.log('after ' + current);
};
const target = {
foo: function (arg) { console.log(this.name + ' and ' + arg); },
name: 'obj'
};
const h1 = around(target, 'foo', countingAdvice);
const h2 = around(target, 'foo', countingAdvice);
target.foo('hello'); // before 2 / before 1 / obj and hello / after 1 / after 2
h1.remove();
target.foo('hello'); // before 2 / obj and hello / after 2
h2.remove();
target.foo('hello'); // obj and hello
用 apply 而不是直接呼叫。包裝鏈裡必須把 arguments 完整往下傳,否則參數會在中途憑空消失。早期寫法裡常見的 originalFunc(arguments) 就是這個 bug——它把整個 arguments 物件當成單一參數傳下去,印出來才會出現 [object Arguments]。
this 要沿鏈傳遞。advice 內部呼叫 original.apply(this, arguments),讓 this 由實際呼叫點決定,而不是寫死成某個物件。這樣同一個包裝才能套用到不同情境。
remove 只清 advised,不清 previous。前面提過,清空 previous 會讓解除後無路可退。判斷標準很簡單:remove() 之後函式應該要「恢復成包裝前的行為」,而不是「變成不可呼叫」。
把這份 around 寫熟,你基本上就掌握了 dojo/aspect 的骨架,也能自己實作出 @before、@after 這類裝飾語法。它比 before/after complex,但换来的是「可以完全接管呼叫流程」的能力——例如快取命中時直接回傳結果而不呼叫原函式,這件事只有 around 做得到。