手把手教你Node使用Promise替代回撥函式

阿新 • • 發佈：2018-11-27

async 的本質是一個流程控制。其實在非同步程式設計中，還有一個更為經典的模型，叫做 Promise/Deferred 模型（當然還有更多相關解決方法，比如 eventproxy，co 等，到時候遇到在挖坑）

首先，我們思考一個典型的非同步程式設計模型，考慮這樣一個題目：讀取一個檔案，在控制檯輸出這個檔案內容

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  console.log(data);
});

看起來很簡單，再進一步: 讀取兩個檔案，在控制檯輸出這兩個檔案內容

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  console.log(data);
  fs.readFile('2.txt', 'utf8', function (err, data) {
    console.log(data);
  });
});//歡迎加入全棧開發交流圈一起學習交流：864305860

要是讀取更多的檔案呢

var fs = require('fs');
fs.readFile('1.txt', 'utf8', function (err, data) {
  fs.readFile('2.txt', 'utf8', function (err, data) {
    fs.readFile('3.txt', 'utf8', function (err, data) {
      fs.readFile('4.txt', 'utf8', function (err, data) {
        // ...
      });
    });//歡迎加入全棧開發交流圈一起學習交流：864305860
  });
});

這就是傳說中的 callback hell，可以使用 async 來改善這段程式碼，但是在本例中我們要用 promise/defer 來改善它 promise 基本概念 首先它是一個物件，它和 javascript 普通的物件沒什麼區別，同時，它也是一種規範，跟非同步操作約定了統一的介面，表示一個非同步操作的最終結果，以同步的方式來寫程式碼，執行的操作是非同步的，但又保證程式執行的順序是同步的

1. promise 只有三種狀態，未完成，完成 (fulfilled) 和失敗 (rejected)
1. promise 的狀態可以由未完成轉換成完成，或者未完成轉換成失敗
1. promise 的狀態轉換隻發生一次

promise 有一個 then 方法，then 方法可以接受 3 個函式作為引數。前兩個函式對應 promise 的兩種狀態 fulfilled, rejected 的回撥函式。第三個函式用於處理進度資訊為了理解它，一些重要原理必須記牢：.then() 總是返回一個新的 promise，如下面程式碼：

var promise = readFile()
var promise2 = promise.then(readAnotherFile, console.error)

這裡 then 的引數 readAnotherFile, console.error 是代表非同步操作成功後的動作 onFulfilled 或失敗後的動作 OnRejected，也就是說，讀取檔案成功後執行 readAnotherFile 函式，否則失敗列印記錄錯誤。這種實現是兩個中只有一種可能也可以理解為：

promiseSomething().then(function (fulfilled) {
  // 當 promise 狀態變成 fulfilled 時，呼叫此函式
}, function (rejected) {
  // 當 promise 狀態變成 rejected 時，呼叫此函式
}, function (progress) {
  // 當返回進度資訊時，呼叫此函式
});//歡迎加入全棧開發交流圈一起學習交流：864305860

Promise 法則有兩部分必須分離：

1. then() 總是返回一個新的 promise，每次你呼叫它，它不管回撥做什麼，因為 .then() 在回撥被呼叫之前已經給了你一個承諾 promise，回撥的行為隻影響承諾 promise 的實施，如果回撥返回一個值，那麼 promise 將使用那個值，如果這個值是一個 promise，返回這個 promise 實施後的值給這個值，如果回撥丟擲錯誤，promise 將拒絕錯誤
1. 被 .then() 返回的 promise 是一個新的 promise ，它不同於那些 .then() 被呼叫的 promise，promise 長長的鏈條有時會好些隱藏這個事實，不管如何，每次 .then() 呼叫都會產生一個新的 promise，這裡必須注意的是你真正需要考慮的是你最後呼叫 .then() 可能代表失敗，那麼如果你不捕獲這種失敗，那麼容易導致你的錯誤 exception 消失

來看一個利用 q 來處理這種問題的簡單例子：

var Q = require('q');
var defer = Q.defer();
/**
 * 獲取初始 promise
 * @private
 */
function getInitialPromise() {
  return defer.promise;
}//歡迎加入全棧開發交流圈一起學習交流：864305860
  
/**
 * 為 promise 設定三種狀態的回撥函式
 */
getInitialPromise().then(function (success) {
  console.log(success);
}, function (error) {
  console.log(error);
}, function (progress) {
  console.log(progress);
});
defer.notify('in progress'); // 控制檯列印 in progress
defer.resolve('resolve');   // 控制檯列印 resolve
defer.reject('reject');    // 沒有輸出。promise 的狀態只能改變一次

promise 的傳遞 then 方法會返回一個 promise，在下面這個例子中，我們用 outputPromise 指向 then 返回的 promise。

var outputPromise = getInputPromise().then(function (fulfilled) {
  
  }, function (rejected) {
  
  });

現在 outputPromise 就變成了受 function(fulfilled) 或者 function(rejected) 控制狀態的 promise 了。直白的意思就是：當 function(fulfilled) 或者 function(rejected) 返回一個值，比如一個字串，陣列，物件等等，那麼 outputPromise 的狀態就會變成 fulfilled。在下面這個例子中，我們可以看到，當我們把 inputPromise 的狀態通過 defer.resovle() 變成 fulfilled 時，控制檯輸出 fulfilled. 當我們把 inputPromise 的狀態通過 defer.reject() 變成 rejected，控制檯輸出 rejected

var Q = require('q');
var defer = Q.defer();
/**//歡迎加入全棧開發交流圈一起學習交流：864305860
 * 通過 defer 獲得 promise
 * @private
 */
function getInputPromise() {
  return defer.promise;
}  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)
 * 當 inputPromise 狀態由未完成變成 rejected 時，呼叫 function(rejected)
 * 將 then 返回的 promise 賦給 outputPromise
 * function(fulfilled) 和 function(rejected) 通過返回字串將 outputPromise 的狀態由
 * 未完成改變為 fulfilled
 * @private
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
var outputPromise = getInputPromise().then(function (fulfilled) {
  return 'fulfilled';
}, function (rejected) {
  return 'rejected';
});  
/**
 * 當 outputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)，控制檯列印 'fulfilled: fulfilled'。
 * 當 outputPromise 狀態由未完成變成 rejected, 呼叫 function(rejected), 控制檯列印 'rejected: rejected'。
 */
outputPromise.then(function (fulfilled) {
  console.log('fulfilled: ' + fulfilled);
}, function (rejected) {
  console.log('rejected: ' + rejected);
});
  /**//歡迎加入全棧開發交流圈一起學習交流：864305860
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
defer.reject(); // 輸出 fulfilled: rejected  
/**
 * 將 inputPromise 的狀態由未完成變成 fulfilled
 */
//defer.resolve(); // 輸出 fulfilled: fulfilled

當 function(fulfilled) 或者 function(rejected) 丟擲異常時，那麼 outputPromise 的狀態就會變成 rejected

var Q = require('q');
var fs = require('fs');
var defer = Q.defer();
  
/**
 * 通過 defer 獲得 promise
 * @private
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
function getInputPromise() {
  return defer.promise;
}
  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)
 * 當 inputPromise 狀態由未完成變成 rejected 時，呼叫 function(rejected)
 * 將 then 返回的 promise 賦給 outputPromise
 * function(fulfilled) 和 function(rejected) 通過丟擲異常將 outputPromise 的狀態由
 * 未完成改變為 reject
 * @private
 */
var outputPromise = getInputPromise().then(function (fulfilled) {
  throw new Error('fulfilled');
}, function (rejected) {
  throw new Error('rejected');
});  
/**
 * 當 outputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)。
 * 當 outputPromise 狀態由未完成變成 rejected, 呼叫 function(rejected)。
 */
outputPromise.then(function (fulfilled) {
  console.log('fulfilled: ' + fulfilled);
}, function (rejected) {
  console.log('rejected: ' + rejected);
});  
/**
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
defer.reject();   // 控制檯列印 rejected [Error:rejected]
  //歡迎加入全棧開發交流圈一起學習交流：864305860
/**
 * 將 inputPromise 的狀態由未完成變成 fulfilled
 */
//defer.resolve(); // 控制檯列印 rejected [Error:fulfilled]

當 function(fulfilled) 或者 function(rejected) 返回一個 promise 時，outputPromise 就會成為這個新的 promise. 這樣做的意義在於聚合結果 (Q.all)，管理延時，異常恢復等等比如說我們想要讀取一個檔案的內容，然後把這些內容打印出來。可能會寫出這樣的程式碼：

// 錯誤的寫法
var outputPromise = getInputPromise().then(function (fulfilled) {
  fs.readFile('test.txt', 'utf8', function (err, data) {
    return data;
  });//歡迎加入全棧開發交流圈一起學習交流：864305860
});

然而這樣寫是錯誤的，因為 function(fulfilled) 並沒有返回任何值。需要下面的方式:

var Q = require('q');
var fs = require('fs');
var defer = Q.defer();
  
/**
 * 通過 defer 獲得promise
 * @private
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
function getInputPromise() {
  return defer.promise;
}
  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil時，呼叫 function(fulfilled)
 * 當 inputPromise 狀態由未完成變成 rejected時，呼叫 function(rejected)
 * 將 then 返回的 promise 賦給 outputPromise
 * function(fulfilled) 將新的 promise 賦給 outputPromise
 * 未完成改變為 reject
 * @private
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
var outputPromise = getInputPromise().then(function (fulfilled) {
  var myDefer = Q.defer();
  fs.readFile('test.txt', 'utf8', function (err, data) {
    if (!err && data) {
      myDefer.resolve(data);
    }
  });//歡迎加入全棧開發交流圈一起學習交流：864305860
  return myDefer.promise;
}, function (rejected) {
  throw new Error('rejected');
});
  
/**
 * 當 outputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)，控制檯列印 test.txt 檔案內容。
 *
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
outputPromise.then(function (fulfilled) {
  console.log(fulfilled);
}, function (rejected) {
  console.log(rejected);
});  
/**
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
//defer.reject();  
/**
 * 將 inputPromise 的狀態由未完成變成 fulfilled
 */
defer.resolve(); // 控制檯打印出 test.txt 的內容

方法傳遞 方法傳遞有些類似於 Java 中的 try 和 catch。當一個異常沒有響應的捕獲時，這個異常會接著往下傳遞方法傳遞的含義是當一個狀態沒有響應的回撥函式，就會沿著 then 往下找 沒有提供 function(rejected)

var outputPromise = getInputPromise().then(function (fulfilled) { })

如果 inputPromise 的狀態由未完成變成 rejected, 此時對 rejected 的處理會由 outputPromise 來完成

var Q = require('q');
var fs = require('fs');
var defer = Q.defer();
/**
 * 通過defer獲得promise
 * @private
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
function getInputPromise() {
  return defer.promise;
}
  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil 時，呼叫 function(fulfilled)
 * 當 inputPromise 狀態由未完成變成 rejected 時，這個 rejected 會傳向 outputPromise
 */
var outputPromise = getInputPromise().then(function (fulfilled) {
  return 'fulfilled'
});//歡迎加入全棧開發交流圈一起學習交流：864305860
outputPromise.then(function (fulfilled) {
  console.log('fulfilled: ' + fulfilled);
}, function (rejected) {
  console.log('rejected: ' + rejected);
});
  /**
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
defer.reject('inputpromise rejected'); // 控制檯列印 rejected: inputpromise rejected
/**
 * 將 inputPromise的狀態由未完成變成fulfilled
 *///歡迎加入全棧開發交流圈一起學習交流：864305860
//defer.resolve();

沒有提供 function(fulfilled)

var outputPromise = getInputPromise().then(null, function (rejected) { })

如果 inputPromise 的狀態由未完成變成 fulfilled, 此時對 fulfil 的處理會由 outputPromise 來完成

var Q = require('q');
var fs = require('fs');
var defer = Q.defer();
  
/**
 * 通過defer獲得promise
 * @private
 */
function getInputPromise() {
  return defer.promise;
}//歡迎加入全棧開發交流圈一起學習交流：864305860
  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil時，傳遞給 outputPromise
 * 當 inputPromise 狀態由未完成變成 rejected時，呼叫 function(rejected)
 * function(fulfilled) 將新的 promise 賦給 outputPromise
 * 未完成改變為 reject
 * @private
 */
var outputPromise = getInputPromise().then(null, function (rejected) {
  return 'rejected';
});  //歡迎加入全棧開發交流圈一起學習交流：864305860
outputPromise.then(function (fulfilled) {
  console.log('fulfilled: ' + fulfilled);
}, function (rejected) {
  console.log('rejected: ' + rejected);
});  
/**
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
// defer.reject('inputpromise rejected');  
/**
 * 將 inputPromise 的狀態由未完成變成fulfilled
 */
defer.resolve('inputpromise fulfilled'); // 控制檯列印fulfilled: inputpromise fulfilled

可以使用 fail(function(error)) 來專門針對錯誤處理，而不是使用 then(null,function(error))

var outputPromise = getInputPromise().fail(function (error) { })

看這個例子：

var Q = require('q');
var fs = require('fs');
var defer = Q.defer();
/**//歡迎加入全棧開發交流圈一起學習交流：864305860
 * 通過defer獲得promise
 * @private
 */
function getInputPromise() {
  return defer.promise;
}
  
/**
 * 當 inputPromise 狀態由未完成變成 fulfil 時，呼叫 then(function(fulfilled))
 * 當 inputPromise 狀態由未完成變成 rejected 時，呼叫 fail(function(error))
 * function(fulfilled) 將新的 promise 賦給 outputPromise
 * 未完成改變為reject
 * @private
 */
var outputPromise = getInputPromise().then(function (fulfilled) {
  return fulfilled;
}).fail(function (error) {
  console.log('fail: ' + error);
});//歡迎加入全棧開發交流圈一起學習交流：864305860
/**
 * 將 inputPromise 的狀態由未完成變成 rejected
 */
defer.reject('inputpromise rejected');// 控制檯列印 fail: inputpromise rejected
  
/**
 * 將 inputPromise 的狀態由未完成變成 fulfilled
 */
//defer.resolve('inputpromise fulfilled');

可以使用 progress(function (progress)) 來專門針對進度資訊進行處理，而不是使用 then(function (success) { }, function (error) { }, function (progress) { })

var Q = require('q');
var defer = Q.defer();
/**
 * 獲取初始 promise
 * @private
 */
function getInitialPromise() {
  return defer.promise;
}
/**//歡迎加入全棧開發交流圈一起學習交流：864305860
 * 為 promise 設定 progress 資訊處理函式
 */
var outputPromise = getInitialPromise().then(function (success) {
  
}).progress(function (progress) {
  console.log(progress);
});
  
defer.notify(1);
defer.notify(2); // 控制檯列印 1，2

promise 鏈 promise 鏈提供了一種讓函式順序執行的方法函式順序執行是很重要的一個功能。比如知道使用者名稱，需要根據使用者名稱從資料庫中找到相應的使用者，然後將使用者資訊傳給下一個函式進行處理

var Q = require('q');
var defer = Q.defer();
// 一個模擬資料庫
var users = [{ 'name': 'andrew', 'passwd': 'password' }];
function getUsername() {
  return defer.promise;
}
  function getUser(username) {
  var user;
  users.forEach(function (element) {
    if (element.name === username) {
      user = element;
    }
  });//歡迎加入全棧開發交流圈一起學習交流：864305860
  return user;
}  
// promise 鏈
getUsername().then(function (username) {
  return getUser(username);
}).then(function (user) {
  console.log(user);
});  
defer.resolve('andrew');

我們通過兩個 then 達到讓函式順序執行的目的。 then 的數量其實是沒有限制的。當然，then 的數量過多，要手動把他們連結起來是很麻煩的。比如

foo(initialVal).then(bar).then(baz).then(qux)

這時我們需要用程式碼來動態製造 promise 鏈

var funcs = [foo, bar, baz, qux]
var result = Q(initialVal) 
funcs.forEach(function (func) {
  result = result.then(func)
})
return result

當然，我們可以再簡潔一點

var funcs = [foo, bar, baz, qux]
funcs.reduce(function (pre, current),Q(initialVal){
  return pre.then(current)
})//歡迎加入全棧開發交流圈一起學習交流：864305860

看一個具體的例子

function foo(result) {
  console.log(result);
  return result + result;
}
  
// 手動連結
Q('hello').then(foo).then(foo).then(foo);
  
// 控制檯輸出： hello
// hellohello
// hellohellohello
  
// 動態連結
var funcs = [foo, foo, foo];
var result = Q('hello');
  
funcs.forEach(function (func) {
  result = result.then(func);
});
  //歡迎加入全棧開發交流圈一起學習交流：864305860
// 精簡後的動態連結
funcs.reduce(function (prev, current) {
  return prev.then(current);
}, Q('hello'));

對於 promise 鏈，最重要的是需要理解為什麼這個鏈能夠順序執行。如果能夠理解這點，那麼以後自己寫 promise 鏈可以說是輕車熟路啊 promise 組合 回到我們一開始讀取檔案內容的例子。如果現在讓我們把它改寫成 promise 鏈，是不是很簡單呢？

var Q = require('q'),
  fs = require('fs');  
function printFileContent(fileName) {
  return function () {
    var defer = Q.defer();
    fs.readFile(fileName, 'utf8', function (err, data) {
      if (!err && data) {
        console.log(data);
        defer.resolve();
      }
    })
    return defer.promise;
  }
} //歡迎加入全棧開發交流圈一起學習交流：864305860
// 手動連結
printFileContent('sample01.txt')()
  .then(printFileContent('sample02.txt'))
  .then(printFileContent('sample03.txt'))
  .then(printFileContent('sample04.txt'));  // 控制檯順序列印 sample01 到 sample04 的內容

我們會發現為什麼要他們順序執行呢，如果他們能夠並行執行不是更好嗎? 我們只需要在他們都執行完成之後，得到他們的執行結果就可以了我們可以通過 Q.all([promise1,promise2...]) 將多個 promise 組合成一個 promise 返回。注意：

1. 當 all 裡面所有的 promise 都 fulfil 時，Q.all 返回的 promise 狀態變成 fulfil
1. 當任意一個 promise 被 reject 時，Q.all 返回的 promise 狀態立即變成 reject

我們來把上面讀取檔案內容的例子改成並行執行吧

var Q = require('q');
var fs = require('fs');
/**//歡迎加入全棧開發交流圈一起學習交流：864305860
 *讀取檔案內容
 *@private
 */
function printFileContent(fileName) {
  // Todo: 這段程式碼不夠簡潔。可以使用 Q.denodeify 來簡化
  var defer = Q.defer();  
  fs.readFile(fileName, 'utf8', function (err, data) {
    if (!err && data) {
      console.log(data);
      defer.resolve(fileName + ' success ');
    } else {
      defer.reject(fileName + ' fail ');
    }
  })  //歡迎加入全棧開發交流圈一起學習交流：864305860
  return defer.promise;  
}  
Q.all([printFileContent('sample01.txt'), printFileContent('sample02.txt'), printFileContent('sample03.txt'), printFileContent('sample04.txt')])
  .then(function (success) {
    console.log(success);
  }); // 控制檯列印各個檔案內容 順序不一定

現在知道 Q.all 會在任意一個 promise 進入 reject 狀態後立即進入 reject 狀態。如果我們需要等到所有的 promise 都發生狀態後(有的 fulfil, 有的 reject)，再轉換 Q.all 的狀態, 這時我們可以使用 Q.allSettled

var Q = require('q'),
  fs = require('fs');
/**
 *讀取檔案內容
 *@private
 */  
function printFileContent(fileName) {  
  // Todo: 這段程式碼不夠簡潔。可以使用Q.denodeify來簡化
  var defer = Q.defer();  
  fs.readFile(fileName, 'utf8', function (err, data) {
    if (!err && data) {
      console.log(data);
      defer.resolve(fileName + ' success ');
    } else {
      defer.reject(fileName + ' fail ');
    }//歡迎加入全棧開發交流圈一起學習交流：864305860
  })
    return defer.promise;    
}  
Q.allSettled([printFileContent('nosuchfile.txt'), 
printFileContent('sample02.txt'), 
printFileContent('sample03.txt'), 
printFileContent('sample04.txt')])
  .then(function (results) {
    results.forEach(
      function (result) {
        console.log(result.state);
      }
    );
  });//歡迎加入全棧開發交流圈一起學習交流：864305860

結束 promise 鏈 通常，對於一個 promise 鏈，有兩種結束的方式。第一種方式是返回最後一個 promise 如 return foo().then(bar); 第二種方式就是通過 done 來結束 promise 鏈如 foo().then(bar).done() 為什麼需要通過 done 來結束一個 promise 鏈呢? 如果在我們的鏈中有錯誤沒有被處理，那麼在一個正確結束的 promise 鏈中，這個沒被處理的錯誤會通過異常丟擲

var Q = require('q'); 
function getPromise(msg, timeout, opt) { 
  var defer = Q.defer(); 
  setTimeout(function () {
    console.log(msg);
    if (opt)
      defer.reject(msg);
    else
      defer.resolve(msg);
  }, timeout); 
  return defer.promise; 
}  //歡迎加入全棧開發交流圈一起學習交流：864305860
/**
 * 沒有用 done() 結束的 promise 鏈
 * 由於 getPromse('2',2000,'opt') 返回 rejected, getPromise('3',1000) 就沒有執行
 * 然後這個異常並沒有任何提醒，是一個潛在的 bug
 */
getPromise('1', 3000)
  .then(function () { return getPromise('2', 2000, 'opt') })
  .then(function () { return getPromise('3', 1000) });
  /**
 * 用 done() 結束的 promise 鏈
 * 有異常丟擲
 */
getPromise('1', 3000)
  .then(function () { return getPromise('2', 2000, 'opt') })
  .then(function () { return getPromise('3', 1000) })
  .done();

promise 代表一個非同步操作的最終結果。主要通過 promise 的 then 方法訂閱其最終結果的處理回撥函式，和訂閱因某原因無法成功獲取最終結果的處理回撥函式。

A 與 A+ 的不同點

A+ 規範通過術語 thenable 來區分 promise 物件
A+ 定義 onFulfilled/onRejectd 必須是作為函式來呼叫，而且呼叫過程必須是非同步的
A+ 嚴格定義了 then 方法鏈式呼叫時，onFulfilled/onRejectd 的呼叫順序

結語

感謝您的觀看，如有不足之處，歡迎批評指正。

手把手教你Node使用Promise替代回撥函式

手把手教你Node使用Promise替代回撥函式

用ES6 Generator替代回撥函式

【計算機內功心法】六：10張圖讓你徹底理解回撥函式

手把手教你寫DI_2_小白徒手擼建構函式注入

手把手教你實現一個微信自動回復機器人

手把手教你做一個 C 語言編譯器（6）：函式定義

小程序初體驗：手把手教你寫出第一個小程序（一）

【騰訊bugly幹貨分享】精神哥手把手教你怎樣智鬥ANR

手把手教你學SVN

手把手教你使用Git

手把手教你用jumpserver搭建堡壘機！

手把手教你做一個吸引人的購物網站

手把手教你提交文件到git

【技術分享】手把手教你使用PowerShell內置的端口掃描器

【實戰篇】手把手教你接LSI9211-8I卡

大數據江湖之即席查詢與分析（下篇）--手把手教你搭建即席查詢與分析Demo

手把手教你SOAP訪問webservice並DOM解析返回的XML數據（轉）

手把手教你玩轉 CSS3 3D 技術（轉載）

12-少年，玩模型嗎？手把手教你statsmodels建模（3）

手把手教你用ngrx管理Angular狀態

手把手教你Node使用Promise替代回撥函式

相關推薦