DIV CSS 佈局教程網

動手打造 JavaScript 自定義事件:從回呼到觀察者模式
編輯:JavaScript基礎知識     

自定義事件的本質就是觀察者模式(又稱發布/訂閱模式)。它的價值在於把「綁定事件」與「觸發事件」彼此隔離,並且可以動態地新增或移除。以下用逐步重構的方式,示範如何從零打造一個可用的自定義事件物件。

起點:把函數寫死

假設我有一個 action1,希望它執行完之後順便觸發 service1:

function service1() {}

function action1() {
  // 其他處理
  // 接著啟動 service1
  service1();
}

需求變了:要觸發好幾個

如果 action1 完成後還要觸發 service2 與 service3,照剛才的思路繼續往後補就是了:

function service1() {}
function service2() {}
function service3() {}

function action1() {
  // 其他處理
  service1();
  service2();
  service3();
}

需求又變了:要能動態增刪

但現在我想在執行階段動態加一個 service4,同時把毫無意義的 service2 拿掉。難不成要回去改 action1 的程式碼?在真實專案中程式碼日益膨脹,這種耦合會很快失控。

第一個念頭是用陣列來管理所有 service:action1 跑到尾端時遍歷一次,逐一執行;不想要某個就從陣列移除,想加新的就 push 進去。

var servicearray = [];

function service1() {}
function service2() {}
function service3() {}

servicearray.push(service1);
servicearray.push(service2);
servicearray.push(service3);

// 刪除指定的 service
function del(arr, fn) {
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] == fn) {
      arr.splice(i, 1);
      break;
    }
  }
}

function action1() {
  // 其他處理
  // 遍歷並執行所有 service
  for (var i = 0; i < servicearray.length; i++) {
    servicearray[i]();
  }
}

// 新增 service4
function service4() {}
servicearray.push(service4);

// 移除 service2
del(servicearray, service2);

再來:把觸發邏輯抽出去

上面這版能用,但復用性不夠,而且 servicearray 與 action1 糾纏在一起。可以另外抽一個觸發函數,讓兩邊鬆散一些:

// 分離 action 與 service
function handleAction(actionName, serviceArr) {
  if (typeof actionName === 'function') {
    actionName();
    for (var i = 0; i < serviceArr.length; i++) {
      serviceArr[i]();
    }
  }
}

handleAction(action1, servicearray);

這裡其實已經帶有回呼函數的味道了——我們想達成的效果就是 action 執行完之後跑一連串 service。但問題是,這種寫法把時機寫死了:只能「之後」。如果我想在 action 之前或之中執行呢?在專案裡反覆改這種函數顯然不是辦法。

關鍵一:用對照表管理關係

解法是用一個物件,把每個 action 名稱對應到它的 service 清單:

/*
  actionObj 用於存放所有 action 與 service 的關聯
  形如:{ action1: [service1, service2], action2: [...] }
*/
var actionObj = {};

// 增加 actionName 與 service 的關聯
function addAction(actionName, fn) {
  if (typeof actionObj[actionName] === 'undefined') {
    actionObj[actionName] = [];
  }
  if (typeof fn === 'function') {
    actionObj[actionName].push(fn);
  }
}

// 觸發 actionName 對應的所有 service
function trigger(actionName) {
  var actionarray = actionObj[actionName];
  if (actionarray instanceof Array) {
    for (var i = 0, len = actionarray.length; i < len; i++) {
      if (typeof actionarray[i] === 'function') {
        actionarray[i]();
      }
    }
  }
}

// 刪除 actionName 中的某個 service
function remove(actionName, fn) {
  var actionarray = actionObj[actionName];
  if (typeof actionName === 'string' && actionarray instanceof Array) {
    if (typeof fn === 'function') {
      for (var i = 0, len = actionarray.length; i < len; i++) {
        if (actionarray[i] === fn) {
          actionObj[actionName].splice(i, 1);
        }
      }
    }
  }
}

這裡做了一個效能上的優化:直接將每個 service 放進 actionObj[actionName],不再額外維護一個 servicearray,trigger 的迴圈也從兩層降為一層。而因為觸發的時機完全由呼叫端決定,我想在 action 之前、之後或中間執行都可以。

關鍵二:不要污染全域

還有個問題:上面全用了全域變數。在模組化開發的環境下這是大忌,於是最後重構為一個構造函數:

var EventTarget = function () {
  this.listener = {};
};

EventTarget.prototype = {
  constructor: EventTarget,

  addAction: function (actionName, fn) {
    if (typeof actionName === 'string' && typeof fn === 'function') {
      // 若該 actionName 還不存在,就新建一個
      if (typeof this.listener[actionName] === 'undefined') {
        this.listener[actionName] = [fn];
      } else {
        this.listener[actionName].push(fn);
      }
    }
  },

  trigger: function (actionName) {
    var actionArray = this.listener[actionName];
    if (actionArray instanceof Array) {
      for (var i = 0, len = actionArray.length; i < len; i++) {
        if (typeof actionArray[i] === 'function') {
          actionArray[i]();
        }
      }
    }
    actionArray = null;
  },

  remove: function (actionName, fn) {
    var actionArray = this.listener[actionName];
    if (typeof actionName === 'string' && actionArray instanceof Array) {
      if (typeof fn === 'function') {
        for (var i = 0, len = actionArray.length; i < len; i++) {
          if (actionArray[i] === fn) {
            this.listener[actionName].splice(i, 1);
          }
        }
      }
    }
    actionArray = null;
  }
};

一個 JavaScript 自定義事件就這樣誕生了。回頭看整段重構歷程,其實就是一部小型的設計模式啟蒙:從寫死的函數呼叫,到用陣列管理,再到鬆耦合的對照表,最後收攏成一個不污染全域的物件。觀察者模式聽起來抽象,動手寫一遍就會發現它非常自然。

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