DIV CSS 佈局教程網

動手實作 JavaScript 的 around 環繞通知
編輯:關於JavaScript     

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,於是它掉進了全域。

第三步:修 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

終於對了。但這一整套要手寫,每包一個函式就要重來一遍,太笨重。把它抽成通用函式:

第五步:抽象成 around

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 的核心手法。

第六步:讓 around 可以被「解除」

如果同一個方法被包了兩次,你會需要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 做得到。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved