Node的异步观点

明白异步非壅塞

提到Node，异步非壅塞会是第一个须要你明白的观点。许多人会把这现实上是两个观点的词等量齐观，以为异步就黑白壅塞的，而同步就是壅塞的。从现实的效果动身，异步IO和非壅塞IO现实上都能抵达我们关于IO沉重的收集应用并行IO的寻求。然则现实上这是两个很不一样的观点。

从操纵系统的内核角度动身，I/O挪用只需两种体式格局，壅塞和非壅塞。两者的区分在于，关于应用壅塞IO挪用，应用递次须要守候IO的悉数历程都悉数完成，即完成悉数IO目标，此时期CPU举行守候，没法取得充足的应用。而关于应用非壅塞IO挪用来讲，应用递次提议IO要求以后不守候数据就马上返回，接下来的CPU时刻片可用于其他使命，由于悉数IO的历程并没有完成，所以还须要应用轮询手艺去探索数据是不是完整预备好。关于轮询手艺细节和生长，此处不过量赘述，很引荐朴灵先生《深入浅出NodeJs》的第三章。

不难明白，从应用递次的角度动身，我不论你操纵系统内核是壅塞的IO挪用还黑白壅塞的IO挪用，只假如我要的数据并没有给我，那末这就是同步的，由于我照旧是在等数据。所以关于这类状况下，应用递次的那“一根筋”就可以够挑选用同步照样异步的体式格局去面临该状况。同步即守候操纵系统给到数据再举行下面的代码（单线程），异步即发出要求以后也马上返回，用某一种体式格局注册未完成的使命（回调函数）然后继承往下实行代码。

明白历程，线程，协程

为了使多个递次能够并发（统一时刻只需一个在运转，时刻维度轻微拉长，就会以为起来像多个同时运转）便有了这个在操纵系统中能够自力运转并作为资本分派的基本单位。

历程是资本分派的基本单位，历程的调理涉及到的内容比较多（存储空间，CPU，I/O资本等，历程现场庇护），调理开支较大，在并发的切换历程效力较低。为了更高效的举行调理，提出了比历程更轻量的自力运转和调理的基本单位线程。最主要的一点统一个历程的多个线程同享历程的资本，这就会暴露出一个多线程编程中须要到场多线程的锁机制来掌握资本的互斥性（同时写变量争执）。线程调理能大幅度减小调理的本钱（相干于历程来讲），线程的切换不会引发历程的切换，然则毕竟照样有本钱。

面临着线程相干的题目，涌现了协程。协程是用户情势下的轻量级线程，操纵系统内查对协程一窍不通，协程的调理完整有应用递次来掌握，操纵系统不论这部份的调理。

协程的特性在因而一个线程实行，因而最大的上风就是协程极高的实行效力。由于子递次切换不是线程切换，而是由递次自身掌握，因而，没有线程切换的开支，和多线程比，线程数目越多，协程的机能上风就越显著。第二大上风就是不须要多线程的锁机制，由于只需一个线程，就也不存在同时写变量争执，在协程中掌握同享资本不加锁，只须要推断状况就好了，所以实行效力比多线程高许多。

依据上述观点自身我们能够能够得出一种暂时性的结论：斟酌到应用多核CPU，而且充足发挥协程的高效力，又可取得极高的机能，面向开发人员最简朴的要领是多历程+协程，既充足应用多核

在Node中应用多核CPU的子历程文档

回调函数题目

在Node中每一个异步的IO回调函数并非由开发人员所掌握主动实行的。

那末关于Node的异步IO，在我们最常应用的异步回调的情势下，我们发出挪用到回调函数实行这中心发作了什么？

悉数历程可简朴的笼统成四个基本要素：IO线程池，观察者，要求对象，以及事宜轮回，盗用《深入浅出NodeJS》的Windows借用IOCP完成异步回调历程的一张图片：

个中所要实行的异步回调函数以及相干的一切状况参数会被封装成一个要求对象然后被推入到IO线程池中，当操纵系统实行完IO取得效果以后会将数据放入要求对象中，并送还当前线程至线程池，关照IOCP完成了IO历程，然后事宜轮回从IO观察者中取得已能够实行的要求对象中的回调，灌注IO数据效果最先实行。

Node自身是多线程的，开发人员的JS代码单线程化身为一个老板，完成高效的异步逻辑依托的是Node机制内部的各个线程池，模仿出了一个异步非壅塞的特性。呈如今开发人员眼前的是表现情势为林林总总的callback构成的一个原生编程作风。

异步编程与“回调地狱”

const fs = require('fs')

fs.readFile("./test1.txt", "utf-8", function(err,content1){
    if (err) {
        console.log(err)
    } else {
        fs.readFile(content1, "utf-8", function(err,content2){
            if (err) {
                console.log(err);
            } else {
                fs.readFile(content2, "utf-8", function(err,content3){
                    if (err) {
                        console.log(err);
                    } else {
                        console.log(content3)
                    }
                });
            }
        });
    }
});

console.log('主线程')


try {
    console.log(content3)
} catch(e) {
    console.log("还没有猎取到content3！");
}

读取的每一个 .txt 文件中的内容是要读取的下一个文件的途径地点，末了一个txt文件（test3.txt）中的内容是“callback hell is not finished……”

打印效果：

主线程
还没有猎取到content3！
callback hell is not finished......

能够明白为Node代码一根筋的往下想尽快终了所谓的主线程，所以碰到设想异步的就自动疏忽并跳过为了往下实行，所以涌现了第一句非异步的打印操纵，打印“主线程”，再往下实行碰到须要打印 content3 这个变量的时刻，主线程就“懵”了，由于定名空间内并没有猎取到任何 content3 的数据，以至在主线程定名空间内都没有定义这个变量，假如不必 try-catch 那末应当会报 “content3 is not defined”的毛病。

另外，callback hell 一清二楚，一味地由于依靠而采纳嵌套回调函数的体式格局，哪怕是上述代码那末简朴的一个原子性的操纵都邑被这类“横向生长”的代码和无休止的大括号嵌套让营业逻辑代码丧失掉可维护性和可读性。

为了防止这类回调地狱，处置惩罚题目的计划和第三方模块就最先屡见不鲜百花齐放了。

这个async不是ES2017的async

async是一个非常壮大，功用非常全面供应异步编程处置惩罚法案的一个第三方npm模块。也是我所打仗的公司中的项目中大局限应用的。下面是关于这个模块的经常使用函数应用引见，先感觉一下。

流程掌握函数

• async.parallel(tasks,callback)

  • tasks 能够是一个数组也能够是个对象，他的数组元素值或许对象的属性值就是一个一个异步的要领。

parallel要领用于并行实行多个要领，一切传入的要领都是马上实行，要领之间没有数据通报。通报给终究callback的数组中的数据依据tasks中声明的递次，而不是实行完成的递次。

//以数组情势传入须要实行的多个要领
async.parallel([
    function(callback){//每一个function均须要传入一个毛病优先的callback
        // 异步函数1，比方 fs.readFile(path,callback)
    },
    function(callback){
        // 异步函数2
    }
],
//终究回调 
function(err, results){
    // 当tasks中的任一要领发作毛病，即回调情势为callback('毛病信息')时，毛病将被通报给err参数，未发作毛病err参数为空
    if(err){
        console.log(err)
    }else{
        let one = results[0];
        let two = results[1];
        //你的种种操纵
    }
    // results中为数组中，两个要领的效果数组：[异步1的效果, 异步2的效果] ，纵然第二个要领先实行完成，其效果也是在第一个要领效果以后
});
 
//以object对象情势传入须要实行的多个要领
async.parallel({
    one: function(callback){
        // 异步函数1
    },
    two: function(callback){
        // 异步函数2
    }
},
function(err, results) {
    // 当tasks中的任一要领发作毛病，即回调情势为callback('毛病信息')时，毛病将被通报给err参数，未发作毛病err参数为空
    // // results 如今等于: {one: 异步1的效果, two: 异步2的效果}
});

• 应用时所要注重的事项：

  • 当tasks中的任一要领发作毛病时，毛病将被通报给终究回调函数的err参数，未发作毛病err参数为空。
  • tasks用数组的写法，纵然第二个要领先实行完成，其效果也是在第一个要领效果以后，两个要领的效果数组：[异步1的效果, 异步2的效果]

个人感觉：这个要领的大批应用让我觉妥当一个要展现许多方面的信息的首页时，解耦成了代码可读性的最关键因素，亲自体味的是应用这个要领在企业营业逻辑中抱负状况是在 tasks 中注册的并行使命取得的效果最好能够直接应用，而不是在第一个async.parallel的终究回调中照旧须要依靠取得的效果再举行下个系列的异步操纵，由于如许致使的效果直接就变成了代码继承向着横向生长，比原生的 callback hell 并没有要好到哪里去。篇幅缘由就不展现现实代码了，总之虽然效果流程取得了一个较为明白的掌握，然则照旧没有优越的可读性

• async.series(tasks,callback)

series要领用于顺次实行多个要领，一个要领实行终了后才会进入下一要领，要领之间没有数据通报!!。

参数和情势与上面的 async.parallel(tasks,callback)一致

//以数组情势传入须要实行的多个要领
async.series([
    function(callback){
       fs.readFile(path1,callback)
    },
    function(callback){
       fs.readFile(path2,callback)
    }
],
// 可选的终究回调 
function(err, results){
    // 当tasks中的任一要领发作毛病，即回调情势为callback('毛病信息')时，毛病将被通报给err参数，未发作毛病err参数为空
    // results中为数组中两个要领的效果数组：['one', 'two'] 
});

这个要领在 tasks 中注册的异步函数之间虽然没有数据通报，然则这个要领掌握了这些个异步要领的实行递次，而且只需一个函数实行失利了接下来的函数就不会再实行了，而且把 err 通报到终究的回调函数中的 err 参数中。正如它的名字 “series”所说，这个要领有点数据库中的事件掌握的意义，只不过原生不支持回滚罢了。

• async.waterfall(tasks,callback)

waterfall要领与series要领相似用于顺次实行多个要领，一个要领实行终了后才会进入下一要领，差别与series要领的是，waterfall之间有数据通报,前一个函数的输出为后一个函数的输入。waterfall的多个要领只能以数组情势传入，不支持object对象。

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        // arg1 如今是 'one'， arg2 如今是 'two' 
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 如今是 'three' 
        callback(null, 'done');
    }
], function (err, result) {
    //实行的使命中要领回调err参数时，将被通报至本要领的err参数
    // 参数result为末了一个要领的回调效果'done'     
});

由于 tasks 中注册的异步函数数组中前一个函数的输出作为后一个输入，很天然的就可以够想到能够经由过程前一个函数通报“处置惩罚胜利信号”在第二个函数中举行推断来举行一系列完整的简朴相似于事件掌握的逻辑操纵。

• async.auto(tasks,callback)

auto要领依据传入的使命范例挑选最好的实行体式格局。不依靠于别的使命的要领将并发实行，依靠于别的使命的要领将在实在行完成后实行。相似于“依靠注入”观点。

async.auto({
    getData: function(callback){
         //一个取数据的要领
        // 与makeFolder要领并行实行
        callback(null, 'data', 'converted to array');
    },
    makeFolder: function(callback){
        // 一个建立文件夹的要领
        // 与make_folder要领并行实行
        callback(null, 'folder');
    },
    writeFile: ['getData', 'makeFolder', function(callback, results){
        // 此要领在守候getData要领和makeFolder实行完成后实行,而且在results中拿到依靠函数的数据
        callback(null, 'filename');
    }],
    sendEmail: ['writeFile', function(callback, results){
        // 守候writeFile实行完成后实行,results中拿到依靠项的数据
        callback(null, {'file':results.writeFile, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

个人评价：喜好这类要领，有清楚的可读性，依靠划定规矩以及掌握一览无余，很可惜的是在我们的代码内里并没有应用。瑕玷是相比较我们的终究处置惩罚计划的文雅，这个照样会有能够嵌套许多层的大括号的体式格局有它自身的劣势。

异步鸠合操纵

• async.each(arr,iterator(item, callback),callback)

对数组arr中的每一项实行iterator操纵。iterator要领中会传一个当前实行的项及一个回调要领。each要领中一切对象是并行实行的。对数组中每一项举行 iterator 函数处置惩罚，假如有一项失足则终究的回调的 err 就回事该 err。然则，失足并不会影响到其他的数组元素实行。

const async = require('async')
const fs = require('fs')
let arr = ['./Test/file1.txt',"./Test/file2.txt","./Test/file3.txt"]
let iterator = (item,callback)=>{   
        fs.readFile(item,"utf-8",(err,results)=>{
            if(item === "./Test/file2.txt"){
                callback(new Error('wrong'))
            }else{
                console.log(results);
                callback(null,results)
            }          
        })      
}
async.each(arr,iterator,function(err){
    if(err){
        console.log(err)
    }
})

打印效果：

3
Error: wrong
    at fs.readFile (/Users/liulei/Desktop/asyncEach/test.js:10:26)
    at FSReqWrap.readFileAfterClose [as oncomplete] (fs.js:511:3)
1

可见，由于并发的缘由，等于第二项失足，也不会影响其他的元素实行。假如想要让数组中的元素依据递次实行，而且一旦一个失足，背面的数组元素都将不会实行的状况应当用另一个函数 async.eachSeeries(arr,iterator(item, callback),callback),用法什么的都一样，这里就不赘述了。

另外，each要领的终究回调函数能够看出来的是，并不会被传入任何效果，所以终究的回调函数就只需一个参数那就是 err，假如想要向终究回调函数中传入某些效果那末还要用到接下来引见的 asycnc.map()

• async.map(arr,iterator(item, callback),callback)

map要领应用体式格局和each完整一样，与each要领差别的是，map要领用于操纵对象的转换，转换后的新的效果集会被通报至终究回调要领中（不失足的状况下）显现一个新的数组的形似。

一样的是，map也是并行操纵，如需按递次而且失足就住手则须要应用 async.mapSeries

向Promise的过渡

Promise基本扼要引见

一个简朴清楚的例子：

const fs = require('fs')

fs.readFile("./Test/file1.txt", "utf-8", (err, content) => {
    if (err) {
        console.log(err);
    } else {
        console.log(content);
    }
})

let readFile = () => {
    return new Promise((resolve, reject) => {
        fs.readFile("./Test/file2.txt", "utf-8", (err, content) => {
            if (err) {
                reject(err)
            } else {
                resolve(content);
            }
        })
    })
}

readFile()
    .then((res) => {
        console.log(res);
    })
    .catch((err) => {
        console.log(err);
    })

只是比原生的callback情势的异步函数多了一步封装包裹的历程。Promise是一个对象，能够把它看作是一个包含着异步函数能够涌现的效果（胜利或许失利（err））的“异步状况小球”。取得了这个小球你就可以用 then 去弄他，用 catch 去捕捉它的失利。简朴的归纳综合，也仅此而已。基于这个小球，我们就可以取得所谓的“当代异步处置惩罚计划”了，后话。

前端 Promisify Ajax要求：

let btn = document.getElementById("btn")
let getData = (api) => {
    return new Promise((resolve,reject)=>{
        let req = new XMLHttpRequest();
        req.open("GET",api,true)       
        req.onload = () => {
              if (req.status === 200) {
                resolve(req.responseText)
              } else {
                reject(new Error(req.statusText))
              }
            }
        
        req.onerror = () => {
              reject(new Error(req.statusText))
            }
            req.send()
          })
        }

btn.onclick = function(e) {
    getData('/api')
        .then((res) => {
            let content=JSON.parse(res).msg
            document.getElementById("content").innerText = content
            })
        .catch((err) => {
            console.log(err);
            })
        }

Node供应的原生模块的API基本上都是基于一个 callback 情势的函数，我们想用 Promise ，难不成以至原生的这些最原始的函数都要我们手动去举行 return 一个 Promise 对象的革新？实在不是如许的，Node 作风的 callback 都顺从着“毛病优先”的回到函数计划，即形如(err,res)=>{}，而且回调函数都是末了一个参数，他们的情势都是一致的。所以Node的原生util模块供应了一个轻易我们将函数 Promisfy 的东西——util.promisfy(origin)

let readFileSeccond = util.promisify(fs.readFile)

readFileSeccond("./Test/file3.txt","utf-8")
    .then((res) => {
        console.log(res);
    })
    .catch((err) => {
        console.log(err);
    })

注重，这个原生东西会对原生回调的效果举行封装，假如在末了的回调函数中除了 err 参数以外，另有不止一个效果的状况，那末 util.promisify 会将效果都统一封装进一个对象当中。

用Promise供应要领应对差别的状况

现实代码逻辑中我们能够会面临种种异步流程掌握的状况，像是之前引见 async 模块一样，一种很罕见的状况就是有许多的异步要领是能够同时并发提议要求的，即相互不依靠对方的效果，async.parallel的效果那样。Promise 除了封装异步以外还未我们供应了一些原生要领去面临相似如许的状况：

学问预备

• Promise.resolve(value)

它是下面这段代码的语法糖：

new Promise((resolve)=>{
    resolve(value)
})

注重点，在 then 挪用的时刻即使一个promise对象是马上进入完成状况的，那Promise的 then 挪用也是异步的，这是为了防止同步和异步之间状况涌现了隐约。所以你能够以为，Promise 只能是异步的，用接下的代码申明：

let promiseA = new Promise((resolve) => {
    console.log("1.组织Promise函数");
    resolve("ray is handsome")
})

promiseA.then((res) => {
    console.log("2.胜利态");
    console.log(res);
})

console.log("3.末了誊写");

上面的代码，打印的效果以下：

1.组织Promise函数
3.末了誊写
2.胜利态
ray is handsome

promise 能够链式 then ，每一个 then 以后都邑发生一个新的 promise 对象，在 then 链中前一个 then 这类能够经由过程 return的体式格局想下一个 then 通报值，这个值会自动挪用 promise.resolve()转化成一个promise对象，代码申明吧：

const fs = require('fs')
let promise = Promise.resolve(1)
promise
    .then((value) => {
            console.log(value)
            return value+1
    })
    .then((value) => {
            console.log(`first那边传下来的${value}`);
            return value+1
    })
    .then((value) => {
            console.log(`second那边传下来的${value}`);
            console.log(value)
    })
    .catch((err) => {
        console.log(err);
    })

上面的代码准许的效果：

1
first那边传下来的2
second那边传下来的3
3

另外 then 链中应当增加 catch 捕捉非常，某一个 then 中涌现了毛病则实行链会跳过厥后的 then 直接进入 catch

取得 async.parallel一样的效果

Promise 供应了一个原生要领 Promise.all(arr),个中arr是一个由 promise 对象构成的一个数组。该要领能够完成让传入该要领的数组中的 promise 同时实行，并在一切的 promise 都有了终究的状况以后，才会挪用接下来的 then 要领，而且取得的效果和在数组中注册的效果保持一致。看下面的代码：

const fs = require('fs')
const util = require('util')

let readFile = util.promisify(fs.readFile)

let files = [readFile("../../Test/file1.txt","utf-8"),
            readFile("../../Test/file2.txt","utf-8"),
            readFile("../../Test/file3.txt","utf-8"),]

Promise.all(files)
    .then((res) => {
        console.log(res)
    })
    .catch((err) => {
        console.log(err);
    })

上面的代码终究会打印,等于按递次的三个txt文件内里的内容构成的数组：

[‘1’,‘2’,‘3’]

对照 async.parallel的用法，发明取得雷同的效果。

另外，与 Promise.all要领相对应的另有一个Promise.race，该要领与all用法雷同，一样是传入一个由 promise 对象构成的数组，你能够把上面的代码中的 all 直接换成 race 看看是什么效果。没错，关于指点 race 这个英文单词意义的能够已猜出来了，race 合作，竞走，就是只需数组中有一个 promise 抵达终究态，该要领的 then 就会实行。所以该代码有能够会涌现’1′,’2′,’3’中的任何一个字符串。

至此，我们处置惩罚了要革新的代码的第一个题目，那就是多异步的同时实行，那末之前 async 模块引见的其他的的功用在现实应用中也很罕见的几个场景，相似递次实行异步函数，异步鸠合操纵要怎样应用新的计划模仿出来呢？真正的原生 async要上台了。

所谓的异步流程掌握的“最终处置惩罚计划”————async

在最先引见 async 之前，想先聊一种状况。

基于 Promise 的这一套看似能够让代码“竖着写”，能够很好的处置惩罚“callbackHell”回调地狱的逆境，然则上述一切的例子都是简朴场景下。在基于 Promise 的 then 链中我们不难发明，虽然一层层往下的 then 链能够向下一层通报本层处置惩罚好的数据，然则这类链条并不能跨层应用数据，就是说假如第3层的 then 想直接应用第一层的效果必须有一个条件就是第二层不仅将本身处置惩罚好的数据 return 给第三层，同时还要把第一层传下来的再一次传给第三层应用。不然另有一种体式格局，那就是我们从回调地狱堕入另一种地狱 “Promise地狱”。

借用这篇博客 的一个操纵 mongoDB 场景例子申明：

MongoClient.connect(url + db_name).then(db => {
    return db.collection('blogs');
}).then(coll => {
    return coll.find().toArray();
}).then(blogs => {
    console.log(blogs.length);
}).catch(err => {
    console.log(err);
})

假如我想要在末了一个 then 中取得 db 对象用来实行 db.close()封闭数据库操纵，我只能挑选让每一层都通报这个 db 对象直至我应用操纵 then 的终点，像下面如许：

MongoClient.connect(url + db_name).then(db => {
    return {db:db,coll:db.collection('blogs')};
}).then(result => {
    return {db:result.db,blogs:result.coll.find().toArray()};
}).then(result => {
    return result.blogs.then(blogs => {   //注重这里，result.coll.find().toArray()返回的是一个Promise，因而这里须要再剖析一层
        return {db:result.db,blogs:blogs}
    })
}).then(result => {
    console.log(result.blogs.length);
    result.db.close();
}).catch(err => {
    console.log(err);
});

下面堕入 “Promise地狱”：

MongoClient.connect(url + db_name).then(db => {
    let coll = db.collection('blogs');
    coll.find().toArray().then(blogs => {
        console.log(blogs.length);
        db.close();
    }).catch(err => {
        console.log(err);
    });
}).catch(err => {
    console.log(err);
})

看上去不是那末显著，然则已涌现了 then 内里嵌套 then 了，操纵一多直接一夜回到解放前，再一次丧失了让人想看代码的欲望。OK，用传说中的 async 呢

(async function(){
    let db = await MongoClient.connect(url + db_name);
    let coll = db.collection('blogs');
    let blogs = await coll.find().toArray();
    console.log(blogs.length);
    db.close();
})().catch(err => {
    console.log(err);
});

种种异步写的像同步了，async（异步）关键字声明，通知读代码的这是一个包含了种种异步操纵的函数，await（得等它）关键字申明背面的是个异步操纵，卡死了等他实行完再往下。这个语义以及视觉确切没法否定这多是“最好的”异步处置惩罚计划了吧。

不得不提的 co 模块

尽人皆知的是 async 函数式 generator 的语法糖，generator 在异步流程掌握中的实行依靠于实行器，co 模块就是一个 generator 的实行器，在真正引见和应用 async 处置惩罚法案之前有必要简朴相识一下赫赫有名的 co 模块。

什么是 generator，细致请参考Ecmascript6 入门

var fs = require('fs');

var readFile = function (fileName){
  return new Promise(function (resolve, reject){
    fs.readFile(fileName, function(error, data){
      if (error) reject(error);
      resolve(data);
    });
  });
};

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};
// 实行生成器，返回一个生成器内部的指针
var g = gen();
//手动 generator 实行器
g.next().value.then(function(data){
  g.next(data).value.then(function(data){
    g.next(data);
  });
})

上述代码采纳 generator 的体式格局在 yeild 关键字背面封装了异步操纵并经由过程 next()去手动实行它。挪用 g.next() 是去实行 yield 背面的异步，这个计划就是典范的异步的“协程”（多个线程相互合作，完成异步使命）处置惩罚计划。

协程实行步骤：

1. 协程A最先实行。
2. 协程A实行到一半，进入停息，实行权转移到协程B。
3. （一段时刻后）协程B交还实行权。
4. 协程A恢复实行。

协程碰到 yield 敕令就停息 比及实行权返回，再从停息的处所继承今后实行。

翻译上述代码：

• gen()实行后返回一个生成器的内部实行指针，gen 生成器就是一个协程。
• gen.next()让生成器内部最先实行代码到碰到 yield 实行 yield 后，就停息该协程，而且交出实行权，此时实行权落到了JS主线程的手里，即最先实行 Promise 的 then 剖析。
• then 的回调里取得了该异步数据效果，挪用g.next(data)经由过程网next()函数传参的情势，将效果返回给生成器的f1变量。
• 顺次回调类推。

申明：

• g.next()返回一个对象，形如{ value: 一个Promise, done: false }到生成器内部代码实行终了返回{ value: undefined, done: true }

引出一个题目: 我们不能每一次用 generator 处置惩罚异步都要手写 generator 的 then 回调实行器，该花样雷同，每次都是挪用.next(),所以能够用递归函数封装成一个函数：

function run(gen){
  var g = gen();

  function next(data){
    var result = g.next(data);
    if (result.done) return result.value;
    result.value.then(function(data){
      next(data);
    });
  }

  next();
}

run(gen);

上述实行器的函数编写 co 模块斟酌全面的写好了，co模块源码

你只须要：

const co = require('co')
co(function* () {
  var res = yield [
    Promise.resolve(1),
    Promise.resolve(2)
  ];
  console.log(res); 
}).catch(onerror);

yield 背面的是并发。

此时我们来对照 async 写法:)

async function(){
    var res = await [
    Promise.resolve(1),
    Promise.resolve(2)
    ]
    console.log(res);
}().catch(onerror);

async 函数就是将 Generator 函数的星号（*）替换成 async，将 yield 替换成 await，仅此而已。而且它不须要分外的实行器，由于它自带 Generator 实行器

本质上实在并没有离开“协程”异步的处置惩罚体式格局

const fs = require('fs')
const util = require('util')


let readFile = util.promisify(fs.readFile);

(async function fn() {
    var a = await readFile('./test1.txt',"utf-8")
    var b = await readFile('./test2.txt',"utf-8")
    console.log(a)
    console.log(b)
})()
.catch((e)=>{
    console.log("失足了")
})



console.log('主线程')

打印效果会先输出“主线程”。

async 处置惩罚计划

前文我们经由过程 Promise.all()处置惩罚了 async.paralle()的功用，如今我们来看看用 Promise 合营原生 async 来抵达“async”模块的其他功用。

• 完成 async.series 递次实行异步函数

//源代码
async.series([
        function(callback) {
            if (version.other_parameters != otherParams) { // 更新其他参数
                var newVersion = {
                    id: version.id,
                    other_parameters: otherParams,
                };
                CVersion.update(newVersion, callback);
            } else {
                callback(null, null);
            }
        },
        function(callback) {
            cVersionModel.removeParams(version.id, toBeRemovedParams, callback);
        },
        function(callback) {
            cVersionModel.addParams(version.id, toBeAddedParams, callback);
        },
        function(callback) {
            CVersion.get(version.id, callback);
        },
    ], function(err, results) {
        if (err) {
            logger.error("更新电路图参数失利！");
            logger.error(version);
            logger.error(tagNames);
            logger.error(err);
            callback(err);
        } else {
            callback(null, results[3].parameters);
        }
    });


//新代码

(async function(){
    if (version.other_parameters != otherParams) { // 更新其参数
        var newVersion = {
            id: version.id,
            other_parameters: otherParams,
        };
        await  CVersion.update(newVersion);
    } else {
        return null
    }
    await cVersionModel.removeParams(version.id, toBeRemovedParams)
    await cVersionModel.addParams(version.id, toBeAddedParams)
    let result = await CVersion.get(version.id)
    return result
})()
..catch((err)=>{
    logger.error("更新参数失利！");
    logger.error(version);
    logger.error(tagNames);
    logger.error(err);
})

• 完成 async.each 的遍历鸠合每一个元素完成异步操纵功用：

//源代码
Notification.newNotifications= function(notifications, callback) {
    function iterator(notification, callback) {
        Notification.newNotification(notification, function(err, results) {
            logger.error(err);
            callback(err);
        });
    }

    async.each(notifications, iterator, function(err) {
        callback(err, null);
    });
}

新代码：

//新代码
Notification.newNotifications= function(notifications）{
  notifications.forEach(async function(notification){
      try{
           await Notification.newNotification(notification)//异步操纵
      } catch (err) {
           logger.error(err);
           return err;
        }    
  });
}

上述代码须要申明的状况是，在forEach 体内的每一个元素的 await 都是并发实行的，由于这恰好满足了 async.each 的特性，假如你愿望的是数组元素继发实行异步操纵，也就是前文所提到的 async.eachSeries 的功用，你须要协程一个 for 轮回而不是 forEach 的情势，相似以下代码：

async function dbFuc(db) {
  let docs = [{}, {}, {}];

  for (let doc of docs) {
    await db.post(doc);//异步数据库操纵
  }
}

假如你以为上述并发鸠合操纵应用 forEach 的体式格局照旧不太直观，也能够改成合营Promise.all的情势：

async function dbFuc(db) {
  let docs = [{}, {}, {}];
  let promises = docs.map((doc) => db.post(doc));

  let results = await Promise.all(promises);
  console.log(results);
}

上述代码现先对数组元素举行遍历，将传入了数组元素参数的一步操纵封装成为一个数组，经由过程await Promise.all(promises)的情势举行并发操纵。Tips： Promise.all 有自动将数组的每一个元素变成Promise对象的才能。