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()这两个语句的区别？