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

 

转载于:https://www.cnblogs.com/Billy-Sherry/p/5200426.html