async框架源碼研究

說來慚愧，以前沒讀過什麼源碼，今天嘗試研究下async框架的源碼，就從https://github.com/bsspirit/async_demo這個地方拉了一個async使用的demo來入手，好，一個一個js，一個一個函數來了解！

 

apply.js

async.apply是給一個函數預綁定多個參數並生成一個可直接調用的新函數，demo中所給出的例子是

 1 function inc(a,b,callback,timeout){　　//先定義一個加法函數
 2     var timeout = timeout || 200;
 3     t.wait(200);
 4     setTimeout(function() {
 5         callback(null, a+b);
 6     }, timeout);
 7 }
 8 var fn = async.apply(inc, 1, 2);　　//調用apply函數且賦予其部分參數
 9 fn(function(err, n){
10     log('1.2 inc: ' + n);
11 }，500);　　　　　　　　　　　　　　　　 //調用apply返回的函數並補齊所需參數，即至關於調用inc函數

由此找到async.js中的apply函數

1 async.apply = _restParam(function (fn, args) {
2     return _restParam(function (callArgs) {　　//返回一個函數並帶有調用該函數時所需參數
3         return fn.apply(
4             null, args.concat(callArgs)　　//將調用所帶參數與已有參數合併，接着傳給自定義的函數（即以前的inc函數）
5         );
6     });
7 });

從以上內容能夠看出，apply的實現原理就是返回一個帶已有參數的函數，而後在調用該函數的時候再傳入其他參數，最後去調用自定義的函數

 

 applyEach.js

async.applyEach能夠實現給一數組中每一個函數傳相同參數，經過callback返回來遍歷全部函數的執行，eachOf函數是實現applyEach的一個函數，如下是源碼：

 1 async.forEachOf =
 2     async.eachOf = function (object, iterator, callback) {
 3         callback = _once(callback || noop);
 4         object = object || [];
 5 
 6         var iter = _keyIterator(object);
 7         var key, completed = 0;
 8 
 9         while ((key = iter()) != null) {
10             completed += 1;　　　　　　　　//這裏用completed累加來計數數組中函數的個數
11             iterator(object[key], key, only_once(done));
12         }
13         
14         if (completed === 0) callback(null);
15 
16         function done(err) {
17             completed--;　　　　　　　　//由於是異步，因此只能經過計數的方法來檢測數組中的函數是否執行結束，直至completed從新變回0即說明所有執行結束
18             console.log(completed);
19             if (err) {
20                 callback(err);
21             }
22             // Check key is null in case iterator isn't exhausted
23             // and done resolved synchronously.
24             else if (key === null && completed <= 0) {
25                 callback(null);
26             }
27         }
28     };

async.applyEachSeries與前者不一樣的是用於實現數組的函數同步執行，研究其源碼的時候遇到比較難理解的是eachOfSeries的實現，源碼：

 1 async.forEachOfSeries =
 2     async.eachOfSeries = function (obj, iterator, callback) {
 3         callback = _once(callback || noop);
 4         obj = obj || [];
 5         var nextKey = _keyIterator(obj);
 6         var key = nextKey();
 7         function iterate() {　　
 8             var sync = true;
 9             if (key === null) {
10                 return callback(null);
11             }
12             iterator(obj[key], key, only_once(function (err) {　　//這裏將函數數組中一個一個取出執行
13                 if (err) {
14                     callback(err);
15                 }
16                 else {
17                     key = nextKey();
18                     if (key === null) {
19                         return callback(null);
20                     } else {
21                         if (sync) {
22                             async.setImmediate(iterate);
23                         } else {
24                             iterate();　　//最終發現是經過遞歸，在處理完成的回調函數中調用自身來實現同步
25                         }
26                     }
27                 }
28             }));
29             sync = false;
30         }
31         iterate();
32     };

之因此要列出eachOf的源碼，是由於裏面用一個變量來檢測異步遍歷執行是否結束的方法相比我以前在一個項目中所用的方法來講是更好的方案，因此以爲要寫一下。可是，仍是存在一些疑問：不理解eachOfSeries源碼中sync存在的意義，還有async.setImmediate(iterate)和iterate()這兩個語句的區別？