async是一個強大的非同步流程控制庫，其語義類似於js對陣列的操作。它提供了一系列非常強大而便捷的方法，有助於我們在javascript單執行緒模型背景下寫出優雅的邏輯控制程式碼。

牛刀小試

先從檔案操作開始初步瞭解async函式庫的作用：

• 使用filter過濾出磁碟中存在的檔案

const fs = require('fs');  
const async = require('async');  

async.filter(['f1', 'f2', 'f3'], function(it, callback) {
    fs.access(it, function
 
(err) {
      callback(null, !err);
    });
}, function(err, results) {
  console.log(results);
});

假設當前目錄下存在以上三個檔案，那麼results輸出為：

['f1', 'f2', 'f3']

• 使用map判斷檔案是否存在

async.map(['f1', 'f2', 'f3'], function(it, callback) {
  fs.exists(function(exists) {
      callback(null, exists);
  });
}, function
 
(err, results) {
    console.log(results);//[true, true, true]
});

以上兩個例子分別使用了access與exists判斷檔案是否存在，關於兩個API的詳細說明，請檢視nodejs官方文件

• 常用的多工並行

function asyncTask(delay, arg) {
    return function(callback) {
        setTimeout(function() {
            console.log(arg + "done");
            callback(null
 
, arg);
        }, delay);
    };
}

async.parallel([
    asyncTask(10, "task1"),
    asyncTask(1, "task2"),
    asyncTask(100, "task3"),
], function(err, ret) {
    console.log(ret);
});

asyncTask輸出的順序依次為：

[[email protected] async]$ node app.js
task2done
task1done
task3done
//ret
[ 'task1', 'task2', 'task3' ]

可見雖然任務是並行的，但是最終的結果依然按照任務陣列的順序排列。

• 順序執行任務

function asyncTask(delay, arg) {
    return function(callback) {
        setTimeout(function() {
            console.log(arg + "done");
            callback(null, arg);
        }, delay);
    };
}

async.series([
    asyncTask(10, "task1"),
    asyncTask(1, "task2"),
    asyncTask(100, "task3"),
], function(err, ret) {
    console.log(ret);
});

輸出：

[[email protected] async]$ node app.js
task1done
task2done
task3done
[ 'task1', 'task2', 'task3' ]  

可以看到任務按照傳入的順序依次執行。

集合型別多工處理

• each
each函式依次遍歷陣列執行回撥函式：

function readFile(file, callback) {
    fs.readFile(file, function(err, ret) {
        console.log("readFile "+ file + " done");
        callback(err);
    });
}

async.each(['f1', 'f2', 'f3'], readFile, function(err) {
    console.log("all done");
});

需要注意的是，each不能保證迭代函式完成的順序，這取決於使用者的具體任務

• forEachOf

each函式可以對陣列進行遍歷，如果想要遍歷的是一個物件，那麼需要用到forEachOf.

function readFile(file, k, callback) {
    fs.readFile(file, function(err, ret) {
        console.log("readFile "+ k + " " + file + " done");
        callback(err);
    });
}

async.forEachOf({k1: "f1", k2: "f2", k3: "f3"}, readFile, function(err) {
    console.log("all done");
});

迭代函式第一個引數是value，第二個引數是key.

• 控制each和foEachOf的順序
  eachSeries與forEachOf都是用來控制迭代函式的順序執行：

function readFile(file, k, callback) {
    fs.readFile(file, function(err, ret) {
        console.log("readFile "+ k + " " + file + " done");
        callback(err);
    });
}

async.forEachOfSeries({k1: "f1", k2: "f2", k3: "f3"}, readFile, function(err) {
    console.log("all done");
});

這樣程式的輸出始終是：

[[email protected] async]$ node app.js
readFile k1 f1 done  
readFile k2 f2 done
readFile k3 f3 done
all done

• 使用apply包裝非同步任務

前面幾個非同步任務都需要人為的額外寫一個函式，如asyncTask，async提供一個apply語法糖用於解決此類問題：

// 使用 apply

async.parallel([
    async.apply(fs.writeFile, 'testfile1', 'test1'),
    async.apply(fs.writeFile, 'testfile2', 'test2'),
]);


// 等同於

async.parallel([
    function(callback){
        fs.writeFile('testfile1', 'test1', callback);
    },
    function(callback){
        fs.writeFile('testfile2', 'test2', callback);
    }
]);

• 使用Limit類函式控制併發數量

async為每個介面都提供了一個Limit引數，使用者限制併發數量，我們利用filterLimit做一個簡單的測試：

var count = 0;
async.filterLimit([1, 10, 28, 90, 10], 2, function(it, callback) {
    count++;
    console.log(it + "開始");
    console.log("併發數：", count);
    setTimeout(function() {
        count--;
        console.log(it + "結束");
        callback(null);
    }, it);
}, function(results) {
    console.log(results);
});

輸出：

[[email protected] async]$ node app.js 
1開始
併發數： 1
10開始
併發數： 2
1結束
28開始
併發數： 2
10結束
90開始
併發數： 2
28結束
10開始
併發數： 2
10結束
90結束
null

可以看到，最大併發數也就是2，雖然待執行任務大於2.

async幾乎提供了全類陣列操作型別的介面，例如：sortBy、reduce、some等，這裡不再一一展開。

非同步控制函式

前面介紹了兩個非同步流程控制函式：series和parallel。下面介紹其他幾個流程控制函式：

• 使用whilst實現while操作

whilst用於實現，類似於while的效果，直到滿足條件，否則持續執行回撥函式。

var c = 0;

async.whilst(function() {
    console.log("judge");
    return c < 3;
}, function(callback) {
    c++;
    console.log("try " + c);
    setTimeout(function() {
        callback(null, c);
    }, 1000);
}, function(err, val) {
    console.log('err', err);
    console.log('value: ', val);
});

輸出：

[[email protected] async]$ node app.js 
judge
try 1
judge
try 2
judge
try 3
judge
err null
value:  3

• 使用waterFall解決非同步任務依賴問題

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
      // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'
});