async的用法

async的用法

在前面的博客，我已经把promise详细讲了一遍，后来有人说async更好用一点，所以这篇博客主要是来讲解async，但是要理解async之前要先了解promise，不然要理解起来是很困难的

async也是一个异步的钩子，他里面有一个属性就是 await，而这个await是非常重要的。

用法是这样的，比如你有两个函数想要转成同步，首先建立两个函数，里面返回的是promise对象，也可以不建立函数，直接建立promise对象
然后里面需要包裹着你需要转化成同步的函数

再用async建立一个函数，然后函数里面有await对象，await对象后面要跟着promise的对象
然后async里面的执行步骤是从上到下，调用async的函数时后面可以加一个then，作用和promise对象相同。

async的主要作用是回调地狱的处理看起来比promise更美观，而且使用async来传参的时候比较方便

async函数必须要等到方法体中所有的await声明Promise函数执行完后，async函数才会得到一个resolve状态的Promise对象。

如果在执行async中的异步函数的过程中，一旦有一个异步函数出现错误，整个async函数就会立即抛出错误，但是如果在async函数中对异步函数通过try/ catch封装，并在catch方法体中返回Promise.reject(),这样async函数将得到一个reject状态的Promise，有效的避免因为异步函数导致整个async函数的终止。

demo1

fs = require("fs");
var fn_1 = function() {
    return new Promise(function (resolve,reject){
        fs.readFile("./a.txt","utf8",function (err,data) {
            if (err){
                throw err
            }
            console.log(data)
            resolve(data)
    })
    })
}

var fn_6 = function() {
    return new Promise(function (resolve,reject){
        fs.readFile("./b.txt","utf8",function (err,data) {
            if (err){
                throw err
            }
            console.log(data)
            resolve(data)
    })
    })
}

async function fn_7() {
    await fn_1();
    await fn_6();
}

fn_7().then(function () {
    console.log("执行结束")
})

这里的用法是这样的，如果你有两个函数，想要把他们转成同步，先需要把这两个函数用promise来包裹着，然后再定义一个函数包裹着promise，这个函数返回的是一个promise对象，如果你觉得麻烦，也可以直接定义一个promise对象

然后再定义一个函数，这个函数一定要是个async的函数。async里面有个await的属性，然后await属性后面是一个promise对象，那么执行async函数的时候，就会按照await的顺序来执行函数，这样就形成了同步

然后运行async的时候也要像promise一样运行，有个then(),作用也是一样的

运行结果

可能你看上面的有点蒙，那我按照这个函数来讲解一下运行逻辑

首先定义一个函数fn_1，里面有个promise对象，对象里面有一个异步的函数readFile。

然后定义一个函数fn_2，里面有个promise对象，对象里面有一个异步的函数readFile。

而现在的需求就是想要把他们按照async的作用转成同步的。

然后我定义了一个函数async 的函数fn_7，里面有两个await，await后面跟着promise对象，也就是fn_1 和 fn_2 的返回的promise对象。

然后我想要同步运行fn_1和fn_2 ,就在async里面把他们排序好，然后执行fn_7就可以了。

执行fn_7的时候要像promise对象一样运行，后面要有个then，作用也是和promise的一样。

demo2

再举一个更好理解的，更简单的例子。

var delay_print_first = function() {
    return new Promise(function (reslove,reject) {
        console.log("First");
        reslove("First")
    });
}
var delay_print_second = function() {
    return new Promise(function (reslove,reject) {
        console.log("Second");
        reslove("Second")
    });
}
var delay_print_third = function() {
    return new Promise(function (reslove,reject) {
        console.log("Third");
        reslove("Third");
    });
}
var async_status = async function(ms) {
    var first = await delay_print_first();
    var send = await delay_print_second();
    var third = await delay_print_third();
    return first + " " + send + " " + third;
}

async_status().then(function (ret) {
    console.log(ret);
})

这里的运行逻辑是这样的，首先建立三个函数，里面返回的都是promise对象，要让他们按照顺序执行的话。就建立一个async_status的async的函数，然后执行顺序的话就是按照await的顺序。

然后async_status的返回值就在下面then的函数里面获取。

有人说这个用起来比较方便，我个人并不是太认同，我就觉得他是在什么时候用起来方便呢，就是当回调地狱过于庞大的时候比较好用，和传参数的时候比较方便。

至于选择什么来实现异步转同步就看大家喜欢了。

如果有什么不懂的地方，或者是想要一起讨论的，可以添加我的QQ1693490575