DIV CSS 佈局教程網

用 Promise 馴服多層非同步:then 鏈的運作原理筆記
編輯:關於JavaScript     

前言

第一次看到 Promise 是 2012 年微軟發表 Windows 8 之後,抱著好奇研究用 HTML5 寫 Metro 應用的時候。當時 WinJS 提供的非同步介面清一色是 Promise 形式,對一個剛畢業、JavaScript 底子薄的人來說簡直像天書,心裡還覺得微軟又在無端搗鼓。

沒想到 2015 年 Promise 被寫進 ES6 標準,調查還顯示 JavaScript 工程師用得有聲有色。諷刺的是,早在 Metro 介面就廣泛使用 Promise 的微軟,自家 IE 直到功成身退都不支援它。

現在回頭看,當初最難理解、也最為人稱道的特性就是 then 函式鏈。它的本質其實就是「把多個非同步過程排隊依序執行」,本文就從這個角度切入。

Promise 想解決什麼

考慮一個場景:延遲 2 秒印一行日誌,再延遲 3 秒印一行,再延遲 4 秒印一行。這件事在多數語言裡再簡單不過,但在 JavaScript 中程式碼會長這樣:

var myfunc = function() {
  setTimeout(function() {
    console.log("log1");
    setTimeout(function() {
      console.log("log2");
      setTimeout(function() {
        console.log("log3");
      }, 4000);
    }, 3000);
  }, 2000);
}

多層嵌套形成典型的金字塔結構,業務一複雜就成了令人聞風喪膽的回呼地獄。

若習慣把邏輯抽成獨立函式,會稍微好一點:

var func1 = function(){ setTimeout(func2, 2000); };
var func2 = function(){ console.log("log1"); setTimeout(func3, 3000); };
var func3 = function(){ console.log("log2"); setTimeout(func4, 4000); };
var func4 = function(){ console.log("log3"); };

視覺上清爽多了,但函式之間的順序依賴仍然得靠人腦維護。

Promise 的定義

借用 MDN 的說法:Promise 物件用於延遲運算與非同步運算,它代表一個尚未完成、但預期未來會完成的操作。它是回傳值的代理,允許你為非同步操作的成功或失敗指定處理方式,使得非同步方法能像同步方法一樣「回傳」結果。

Promise 有三種狀態:

· pending:初始狀態,既非 fulfilled 也非 rejected。

· fulfilled:操作成功。

· rejected:操作失敗。

pending 狀態只能轉為 fulfilled(帶成功值)或 rejected(帶失敗原因),且不可逆。狀態轉換時,透過 then 綁定的處理函式就會被呼叫。若綁定時 promise 已經定案,該函式會被立刻執行——因此在「非同步完成時機」與「綁定時機」之間不存在競態條件,這是 Promise 設計上相當關鍵的一點。

動手試試

先執行一次延遲與回呼:

new Promise(function(res, rej) {
  console.log(Date.now() + " start setTimeout");
  setTimeout(res, 2000);
}).then(function() {
  console.log(Date.now() + " timeout call back");
});

要再加一段延遲,直覺寫法是把新的 Promise 塞進 then 裡:

new Promise(function(res, rej) {
  setTimeout(res, 2000);
}).then(function() {
  new Promise(function(res, rej) {
    setTimeout(res, 3000);
  }).then(function() {
    console.log("timeout 2 call back");
  });
});

能跑,但金字塔又回來了,根本背離了引入 Promise 的初衷。

問題出在 then 的返回值。

then 與 onFulfilled 的返回值規則

關鍵事實:then() 會回傳一個新的 Promise,因此可以再接 then,形成 new Promise(...).then(...).then(...) 的鏈條。而這個新 Promise 的樣貌,取決於 onFulfilled 回呼的返回值。

如果 onFulfilled 回傳普通值,then 會回傳一個已注定 fulfilled 的 Promise,下一個 then 的回呼會立刻被執行,且入參就是剛才那個值:

new Promise(function(res, rej) {
  setTimeout(res, 2000);
}).then(function() {
  console.log("timeout 1 call back");
  return 1024;
}).then(function(arg) {
  console.log("last onFulfilled return " + arg);  // 1024
});

如果 onFulfilled 回傳的是另一個 Promise,那麼這個 Promise 就會成為 then 的返回值——下一個 then 會等它定案才觸發。這正是串接非同步流程的正確姿勢:

new Promise(function(res, rej) {
  setTimeout(res, 2000);
}).then(function() {
  console.log("timeout 1 call back");
  return new Promise(function(res, rej) {
    setTimeout(res, 3000);
  });
}).then(function() {
  console.log("timeout 2 call back");
  return new Promise(function(res, rej) {
    setTimeout(res, 4000);
  });
}).then(function() {
  console.log("timeout 3 call back");
});

執行結果:

start setTimeout 1
timeout 1 call back
start setTimeout 2
timeout 2 call back
start setTimeout 3
timeout 3 call back

幾段延遲被整齊地排成一列,完全沒有嵌套。雖然跑的都是非同步過程,讀起來卻像同步程式碼——這就是 Promise 的價值所在。

若再養成把長邏輯抽成函式的習慣,程式碼會更乾淨:

function timeout1() {
  return new Promise(function(res, rej){
    console.log(Date.now() + " start timeout1");
    setTimeout(res, 2000);
  });
}
function timeout2() {
  return new Promise(function(res, rej){
    console.log(Date.now() + " start timeout2");
    setTimeout(res, 3000);
  });
}

timeout1()
  .then(timeout2)
  .then(function(){ console.log(Date.now() + " done"); });

那 onFulfilled 的入參從哪來

前面提到:若上一個 onFulfilled 回傳普通值,該值就是下一個的入參。若回傳的是 Promise,入參則是該 Promise 呼叫 resolve 時傳入的值。

用 Node.js 的 fs.readFile 對照就很清楚。原生寫法:

fs.readFile('/etc/passwd', function (err, data) {
  if (err) throw err;
  console.log(data);
});

它無論成敗都呼叫同一個回呼,因此需要 err 與 data 兩個參數。改用 Promise 封裝:

function readFile(fileName) {
  return new Promise(function(resolve, reject) {
    fs.readFile(fileName, function (err, data) {
      if (err) { reject(err); }
      else     { resolve(data); }
    });
  });
}

readFile('theFile.txt').then(
  function(data){ console.log(data); },
  function(err){ throw err; }
);

還記得在其他語言中,同步讀檔函式的檔案內容放在哪裡嗎?——放在回傳值。對應到 Promise,resolve() 的入參就是那個回傳值。於是「onFulfilled 的入參來自上一個 resolve 的值」這件事就完全說得通了:onFulfilled 的職責本來就是處理上一個非同步操作的結果。

總結

function callp1() {
  return new Promise(function(res, rej){ setTimeout(res, 2000); });
}
function callp2() {
  return new Promise(function(res, rej){
    setTimeout(function(){
      res({arg1: 4, arg2: "arg2 value"});
    }, 3000);
  });
}
function callp3(arg) {
  return new Promise(function(res, rej){
    setTimeout(function(){ res("callp3"); }, arg * 1000);
  });
}

callp1()
  .then(function() {
    console.log(Date.now() + " callp1 return");
    return callp2();
  })
  .then(function(ret) {
    console.log(Date.now() + " callp2 return " + JSON.stringify(ret));
    return callp3(ret.arg1);
  })
  .then(function(ret) {
    console.log(Date.now() + " callp3 return " + ret);
  });

三個非同步函式依序執行,前一步的輸出直接餵給下一步,整條流程既沒有嵌套,也能自然傳遞資料。把「then 回傳新 Promise」與「resolve 的值就是下一步的入參」這兩件事記牢,Promise 就不再神祕了。

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