DIV CSS 佈局教程網

JavaScript 非同步方法的隊列鏈:讓 AJAX 也能 chain 下去
編輯:關於JavaScript     

《JavaScript 設計模式》一書對某種技巧有相當詳細的描述:想實現方法的鏈式呼叫,只要在原型上定義的方法都回傳該實例的參照即可。書中給了這樣一段程式:

同步版本的鏈式呼叫

(function () {
  function _$(els) {
    this.elements = [];
    for (var i = 0, len = els.length; i < len; ++i) {
      var element = els[i];
      if (typeof element == 'string') {
        element = document.getElementById(element);
      }
      this.elements.push(element);
    }
  }

  _$.prototype = {
    each: function (fn) {
      for (var i = 0, len = this.elements.length; i < len; ++i) {
        fn.call(this, this.elements[i]);
      }
      return this;
    },
    setStyle: function (prop, val) {
      this.each(function (el) { el.style[prop] = val; });
      return this;
    },
    show: function () {
      var that = this;
      this.each(function () { that.setStyle('display', 'block'); });
      return this;
    },
    addEvent: function (type, fn) {
      var add = function (el) {
        if (window.addEventListener) {
          el.addEventListener(type, fn, false);
        } else if (window.attachEvent) {
          el.attachEvent('on' + type, fn);
        }
      };
      this.each(function (el) { add(el); });
      return this;
    }
  };

  window.$ = function () { return new _$(arguments); };
})();

每個方法都以 return this 收尾,於是呼叫結果又被傳給鏈上的下一個方法。問題來了:如果我們要操作的資料是透過非同步請求取得的,鏈還能維持嗎?

答案是不能——至少在直覺上不能。因為 $.ajax() 立刻返回,而資料要等回呼才到,那時 return this 早就執行完了。Dustin Diaz 提供了一個漂亮的解法。

Queue:把回呼排隊,等資料到了再一次發送

function Queue() {
  this._methods  = [];    // 等待中的回呼
  this._response = null;  // 非同步取得的結果
  this._flushed  = false; // 是否已經「沖洗」過
}

Queue.prototype = {
  // 加入回呼
  add: function (fn) {
    if (this._flushed) {
      fn(this._response);        // 資料已就緒,立刻執行
    } else {
      this._methods.push(fn);    // 否則排入隊列
    }
  },

  // 資料到達時,一次清空隊列
  flush: function (resp) {
    if (this._flushed) return;   // 只 flush 一次
    this._response = resp;
    this._flushed  = true;
    while (this._methods[0]) {
      this._methods.shift()(resp);
    }
  }
};

這個設計的關鍵在 _flushed 旗標。在資料到達之前呼叫 add,回呼會被存起來;資料到達後呼叫 flush,隊列中的回呼依序以資料為參數執行。而在 flush 之後才呼叫 add 的話,回呼會立刻執行——這讓「先後順序」在兩種情況下都能正確運作,是整個技巧成立的核心。

應用在 jQuery 外掛上

(function ($) {
  $.fn.fetch = function (url) {
    var queue = new Queue;

    this.each(function () {
      var el = this;
      queue.add(function (resp) {
        $(el).html(resp);
      });
    });

    $.ajax({
      url: url,
      dataType: 'html',
      success: function (html) { queue.flush(html); }
    });

    return this;
  };
})(jQuery);

於是鏈式呼叫就能跨過非同步的界線繼續下去:

$("<div/>")
  .fetch('/server/navigation.html')
  .addClass('column')
  .appendTo('#side');

多步非同步處理

若一個隊列裡有很多步驟都要等伺服器回應,可以把它包進建構子裡:

function fetchTweet(url) {
  this.queue = new Queue;
  this.tweet = "";
  var self = this;

  ajax(url, function (resp) {
    self.tweet = resp;
    self.queue.flush(this);
  });
}

fetchTweet.prototype = {
  linkify: function () {
    this.queue.add(function (self) {
      self.tweet = self.tweet.replace(/\b@(\w{1,20})\b/g, '$1');
    });
    return this;
  },
  filterBadWords: function () {
    this.queue.add(function (self) {
      self.tweet = self.tweet.replace(/\b(fuck|shit|piss)\b/g, "");
    });
    return this;
  },
  appendTo: function (selector) {
    this.queue.add(function (self) {
      $(self.tweet).appendTo(selector);
    });
    return this;
  }
};

呼叫方式與同步版本別無二致:

fetchTweet(url).linkify().filterBadWords().appendTo('#status');

值得追問的幾個問題

原文下方的評論區提出了幾個很值得思考的質疑,這裡整理如下。

第一,$.fn.fetch 只是把回傳內容附加到元素上,真的需要 Queue 嗎?jQuery 的 $.fn.load 本來就能做到。若隊列裡只有一個回呼,直接寫就好:

(function ($) {
  $.fn.fetch = function (url) {
    var queue = new Queue;
    this.each(function () {
      var el = this;
      $.ajax({
        url: url,
        type: 'get',
        dataType: 'json',
        success: function (resp) { $(el).html(resp['text1']); }
      });
    });
    return this;
  };
})(jQuery);

第二,這個 Queue 實作有個明顯的副作用:flush 之後才 add 的回呼會立即執行,這在語意上讓「鏈式呼叫」變成了「依照註冊時機決定何時執行」,充滿了隱性狀態。用的人若不理解 _flushed,很容易寫出順序錯亂的程式碼。

第三,也是最根本的一點:這個技巧之所以看起來優雅,是因為它把「非同步」偽裝成「同步」。但兩者的本質終究不同——非同步可能失敗,鏈式呼叫卻沒有表達失敗的位置。

今日的答案很清楚:用 Promise。它把「 eventual 的值」變成一等公民,鏈式呼叫自然成立,而且 .catch() 提供了同步鏈永遠缺的那個錯誤分支:

fetch('/server/navigation.html')
  .then(function (res) { return res.text(); })
  .then(function (html) {
    return $("<div/>").addClass('column').appendTo('#side').html(html);
  })
  .catch(function (e) { console.error('載入失敗', e); });

用 async/await 甚至能寫成完全線性的樣子。Queue 這個實作的價值,在於它示範了「如何把非同步的資料注入到一個同步風格的鏈條裡」這個問題本身——理解了那個問題,才會明白 Promise 為什麼是更好的答案。

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