DIV CSS 佈局教程網

JS 鏈式調用怎麼實現:從返回 this 到惰性求值
編輯:JavaScript基礎知識     

鏈式調用我們天天在用,比如 jQuery 的 $(ele).show().find(child).hide(),又比如 AngularJS 的 $http.get(url).success(fn_s).error(fn_e)。但這些都是已經包裝好的成品,我們享受了鏈式調用帶來的順手,卻很少去想背後是怎麼串起來的。

隨著鏈式調用普及,實作方案也越來越多。最常見的三種是:jQuery 直接回傳 this、underscore 的可選式(_.chain()),以及 lodash 的惰性求值。下面逐一拆解,並各寫一個 demo。

方案一:直接回傳 this

這是最常見、也是所有方案的基礎。我們做一個簡單的鏈式運算類,首先得有個欄位保存結果:

function A(num) {
  this.value = num || 0; // 這裡就不做傳參校驗了
}

接著加上運算方法,關鍵是每個方法都要把 this 回傳出去:

A.prototype.add    = function(a) { this.value += a; return this; };
A.prototype.reduce = function(a) { this.value -= a; return this; };

最後補上兩個轉換方法,方便觀察結果:

A.prototype.valueOf  = function() { return this.value; };
A.prototype.toString = function() { return this.value + ''; };

驗證一下:

var a = new A(2);
alert(a.add(1).reduce(2)); // 1

這個 demo 簡單到不需要任何說明,我們直接進入第二種。

方案二:underscore 的 chain

underscore 規定了兩種呼叫風格:_.forEach(arr, fn) 這種直接呼叫,以及 _.chain(arr).forEach(fn).map(fn) 這種鏈式。

先實作前者。這裡不談 underscore 的細節,只簡化實作 forEach 與 map,且僅處理陣列:

var _ = {};

_.forEach = function(array, fn) {
  array.forEach(function(v, i, array) { fn.apply(v, [v, i, array]); });
};

_.map = function(array, fn) {
  return array.map(function(v, i, array) { return fn.apply(v, [v, i, array]); });
};

接下來問題來了:要支援鏈式,第一步該做什麼?觀察第二種呼叫方式可以發現,無論 forEach 還是 map 都是在 _.chain(arr) 的回傳值上呼叫的。所以 _.chain(arr) 必須回傳一個物件,而這個物件上要有與 _ 相同的方法,只是原來的第一個參數被固定成了 chain 傳入的那份資料。

確定了要回傳物件,那它的建構函式怎麼寫?我們借用 _ 這個變數本身來充當——函式也是物件,把 _ 從物件改成函式,不會破壞既有的邏輯:

var _ = function(array) {
  this._value = Array.prototype.slice.apply(array);
};

_.forEach = function(array, fn) {
  array.forEach(function(v, i, array) { fn.apply(v, [v, i, array]); });
};

_.map = function(array, fn) {
  return array.map(function(v, i, array) { return fn.apply(v, [v, i, array]); });
};

_.chain = function(array) { return new _(array); };

新建構函式有了,但它生成的物件除了 _value 之外一片空白。怎麼把 _ 上的方法稍作修改後搬過去?用迴圈加閉包:

for (var i in _) {
  if (i !== 'chain') {           // chain 不需要搬
    _.prototype[i] = (function(i) {
      // i 是迴圈變數,必須靠閉包轉成局部變數,否則全部會指向最後一個值
      return function() {
        var args = Array.prototype.slice.apply(arguments);
        args.unshift(this._value);  // 把 _value 塞進參數第一位

        if (i === 'map') {
          // map 有回傳值,需要更新 _value
          this._value = _[i].apply(this, args);
        } else {
          // forEach 沒有回傳值,_value 保持不變
          _[i].apply(this, args);
        }
        return this;                // 回傳 this 才能繼續串下去
      };
    })(i);
  }
}

最後模仿 underscore,補一個 value() 取出結果:

_.prototype.value = function() { return this._value; };

驗證:

var a = [1, 2, 3];
_.forEach(a, function(v){ console.log(v); });
alert(_.map(a, function(v){ return ++v; }));
alert(_.chain(a).map(function(v){ return ++v; })
                  .forEach(function(v){ console.log(v); })
                  .value());

方案三:lodash 的惰性求值

最複雜的來了。先解釋什麼是惰性調用。

看 _.chain(arr).forEach(fn).map(fn).value() 這個鏈:執行到 chain(arr) 時回傳一個物件;執行到 forEach 時開始輪詢,跑完再回傳該物件;執行到 map 時又輪詢一次,跑完再回傳;最後 value 取出 _value。每一步都是獨立、依序完成的。

惰性調用則是:執行到 forEach 時不跑,只是把這個操作塞進佇列;執行到 map 時再把 map 也塞進佇列。那什麼時候才真正執行?當某個特定操作(例如 value)被塞進佇列時,才一口氣把前面排隊的全部跑完。

惰性調用有什麼好處?傳統鏈式操作的格式是 obj.job1().job2().job3(),整條鏈上就只有 job,沒有 controller。如果需求變成「連續執行 100 次 job1-3」,傳統寫法得重複 100 次,或者用 for 迴圈把整條鏈打斷。而加上 controller 之後,用惰性調用可以寫成 obj.loop(100).job1().job2().job3().end().done()——loop 宣告開啟 100 次迴圈,end 結束本次迴圈,done 是開始執行的標誌。程式碼量差得非常明顯。

動手實作。既然任何 controller 或 job 的呼叫都是「把操作塞進佇列」,那建構函式自然要有個佇列屬性;有了佇列,就得有索引標明目前執行到哪;要做 loop,還需要總次數與目前次數,以及一個記錄迴圈起點的屬性:

function Task() {
  this.queen = [];      // 任務佇列
  this.queenIndex = 0;  // 目前執行的索引
  this.loopCount = 0;   // loop 總次數
  this.loopIndex = 0;   // 目前是第幾次 loop
  this.loopStart = 0;   // 本次 loop 從佇列哪一項開始
}

接著實作 controller 與 job,以 job()、loop()、end()、done() 為例。它們其實各有兩副面孔:一副是本身的業務邏輯(job 就是 do something;loop 負責記錄 loopCount 與 loopStart;end 負責 loopIndex + 1 並判斷是否要跳回 loopStart),另一副則是不管業務是什麼,一律把對應操作塞進任務佇列——這副面孔可以視為前一種的「包裝器」。

既然最終呼叫格式是 new Task().loop(100).job().end().done(),那鏈上的方法就是包裝器,該放在 Task.prototype 上;而第一種形態(真正的業務邏輯)就放到 Task.prototype.__proto__ 上:

var _task_proto = {
  loop: function(num) {
    this.loopStart = this.queenIndex;
    this.loopCount = num;
  },
  job: function(str) {
    console.log(str);
  },
  end: function() {
    this.loopIndex++;
    if (this.loopIndex < this.loopCount) {
      this.queenIndex = this.loopStart; // 回到迴圈起點
    } else {
      this.loopIndex = 0;
    }
  },
  done: function() {
    console.log('done');
  }
};
Task.prototype.__proto__ = _task_proto;

然後遍歷 _task_proto,在 Task.prototype 上生成對應的包裝器,並讓每個包裝器回傳 this 以維持鏈式:

for (var i in _task_proto) {
  (function(i) {
    var raw = Task.prototype[i];
    Task.prototype[i] = function() {
      // 把實作方法、名稱與參數存進任務佇列
      this.queen.push({ name: i, fn: raw, args: arguments });
      return this;
    };
  })(i);
}

現在問題來了:什麼時候開始執行?又怎麼讓任務有條不紊地執行與跳轉?我們在 Task.prototype 上定義一個專門負責調度的方法。由於佇列是依序執行、以索引定位的,與迭代器頗為神似,就把它取名為 next:

Task.prototype.next = function() {
  var task = this.queen[this.queenIndex]; // 取出下一個任務
  task.fn.apply(this, task.args);         // 執行真正的實作並帶入參數

  if (task.name !== 'done') {
    this.queenIndex++;
    this.next();          // 還沒結束,索引 +1 後繼續
  } else {
    this.queen = [];      // 全部跑完,清空佇列
    this.queenIndex = 0;  // 重置索引
  }
};

有了 next,還得在 done 的包裝器上補一句,讓佇列真正啟動:

for (var i in _task_proto) {
  (function(i) {
    var raw = Task.prototype[i];
    Task.prototype[i] = function() {
      this.queen.push({ name: i, fn: raw, args: arguments });
      if (i === 'done') { this.next(); }  // done 是啟動開關
      return this;
    };
  })(i);
}

最後驗證:

var t = new Task();

console.log('1');
t.job('fuck').loop(3).job('world').end()
 .loop(3).job('world').end()
 .job('!').done();

console.log('2');
t.job('fuck').loop(3).job('world').job('!').end().done();

console.log('3');
t.job('fuck').loop(3).job('world').job('!').end().job('!');

鏈式調用玩到這裡大致完整了。這幾個 demo——尤其是惰性調用那一版——稍加改造就能擴充出相當可觀的能力,像是加入條件跳轉、非同步任務、錯誤處理等,這裡就不再展開。

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