async函数学习笔记

雨点打透心脏的1/2处 2022-04-03 12:44 146阅读 0赞

## 含义 ##

async函数是什么？一句话，它就是Generator函数的语法糖。

一比较就会发现，async函数就是将Generator函数的星号替换成async，将yield替换成await，仅此而已。  
async函数对Generator函数的改进，体现在以下四点。  
（1）内置执行器  
Generator函数的执行必须靠执行器，所以才有了co模块，而async函数自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行。

asyncReadFile()

上面的代码调用了asyncReadFile函数，然后它就会自动执行，输出最后结果。这完全不像Generator函数，需要调用next方法，或则用co模块，才能真正执行，得到最后结果。  
（2）更好的语义  
async和await，比起星号和yield，语义更清楚了。async表示函数里有异步操作，await表示紧跟在后面的表达式需要等待结果。  
（3）更广的适用性  
co模块约定，yield命令后面只能是Thunk函数或Promise对象，而async函数的await命令后面，可以是Promise对象和原始类型的值（数值、字符串和布尔值，但这时等同于同步操作）。  
（4）返回值是Promise  
async函数的返回值是Promise对象，这比Generator函数的返回值Iterator对象方便多了。你可以用then方法指定下一步的操作。  
进一步说，async函数完全可以看作多个异步操作，包装成的一个Promise对象，而await命令就是内部then命令的语法糖。

基本用法

async函数返回一个Promise对象，可以使用then方法添加回调函数。当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。  
下面是一个例子。

async function getStockPriceByName(name){
        const symbol = await getStockSymbol(name);
        const stockPrice = await getStockPrice(symbol);
        return stockPrice;
    }
    getStockPriceByName('goog').then(function(result){
        console.log(result);
    })

上面代码是一个获取股票报价的函数，函数前面的async关键字，表明该函数内部有异步操作。调用该函数时，会立即返回一个Promise对象。  
下面是另一个例子，指定多少毫秒后输出一个值。

由于async函数返回的是Promise对象，可以作为await命令的参数。所以，上面的例子也可以写成下面的形式。

async function timeout(ms){
        await new Promise((resolve)=>{
            setTimeout(resolve,ms);
        })
    }
    
    async function asyncPrint(value, ms) {
        await timeout(ms);
        console.log(value);
    }
    
    asyncPrint('hello world', 5000);

async函数有多种使用形式。

//函数声明
    async function foo(){}
    //函数表达式
    const foo = async function(){};
    //对象的方法
    let obj = {async foo(){}};
    obj.foo().then(...)
    //Class的方法
    class Storage{
        constructor(){
            this.cachePromise = caches.open('avatars');
        }
        async getAvatar(name){
            const cache = await this.cachePromise;
            return cache.match(`/avatars/${name}.jpg`);
        }
    }
    const storage = new Storage();
    storage.getAvatar('jake').then(...);
    //箭头函数
    const foo = async()=>{};

## 返回Promise对象 ##

async函数返回一个Promise对象。  
async函数内部return语句返回的值，会成为then方法回调函数的参数。

async function f(){
        return 'hello world';
    }
    f().then(v=>console.log(v))//'hello world'

上面代码中，函数f内部return命令返回的值，会被then方法回调函数接收到。  
async函数内部抛出错误，会导致返回Promise对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。

async function f(){
        throw new Error('出错了');
    }
    f().then(
        v=>console.log(v),
        e=>console.log(e)
    )
    //Error;出错了

## Promise对象的状态变化 ##

async函数返回的Promise对象，必须等到内部所有await命令后面的Promise对象执行完，才会发生状态改变，除非遇到return语句或则抛出错误。也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。

async function getTitle(url) {
      let response = await fetch(url);
      let html = await response.text();
      return html.match(/<title>([\s\S]+)<\/title>/i)[1];
    }
    getTitle('https://tc39.github.io/ecma262/').then(console.log)

上面代码中，函数getTitle内部有三个操作：抓取网页、取出文本、匹配页面标题。只有这三个操作全部完成，才会执行then方法里面的console.log()  
await命令  
正常情况下，await命令后面是一个Promise对象，返回该对象的结果。如果不是Promsie对象，就直接返回对应的值。

async function f(){
        //等同于123；
        return await 123;
    }
    f().then(v=>console.log(v))

上面代码中，await命令的参数是数值123，这时等同于return 123.  
另一种情况是，await命令后面是一个thenable对象(即定义then方法的对象)，那么await会将其等同于Promise对象。

class Sleep{
        constructor(timeout){
            this.timeout = timeout;
        }
        then(resolve,reject){
            const startTime = Date.now();
            setTimeout(
                ()=>resolve(Date.now()-startTime)
                this.timeout
            )
        }
    }
    (async()=>{
        const actualTime = await new Sleep(1000);
        console.log(actualTime);
    })();

上面代码中，await命令后面是一个Sleep对象的实例。这个实例不是Promise对象，但是因为定义了then方法，await会将其视为Promise处理。  
await命令后面的Promise对象如果变为reject状态，则reject的参数会被catch方法的回调函数接收到。

async function f(){
        await Promise.reject('出错了');
    }
    f().then(v=>console.log(v)).catch(e=>console.log(e));

注意，上面代码中，await语句前面没有return，但是reject方法的参数依然传入到catch方法的回调函数。这里如果是await前面加上return，效果是一样的。  
任何一个await语句后面的Promise对象变为reject状态，那么整个async函数都会中断执行。  
有时，我们希望即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，第二个await都会执行。

async function f(){
        try{
            await Promise.reject('出错了');
        }catch(e){
        }
        return await Promise.resolve('hello world');
    }
    f().then(v=>console.log(v))//hello world

另一种方法是await后面的Promise对象再跟一个catch方法，处理前面可能出现的错误。

async function f(){
        await Promise.reject('出错了')
            .catch(e=>console.log(e));
        return await Promise.resolve('hello world');
    }
    f().then(v=>console.log(v))
    //出错了
    //hello world

错误处理  
如果await后面的异步操作出错，那么等同于async函数返回的Promise对象被reject。防止出错的方法，也是将其放在try...catch代码块之中。

async function f(){
        try{
            await new Promise(function(resolve,reject){
                throw new Error('出错了')
            });
        }catch(e){}
        return await('hello world');
    }

如果有多个await命令，可以统一放在try...catch结构中。

async function main(){
        try{
            const val1 = await firstStep();
            const val2 = await secondStep(val1);
            const val3 = await thirdStep(val1,val2);
            console.log('Final',val3);
        }
        catch(err){
            console.error(err);
        }
    }

下面的例子使用try...catch结构，实现多次重复尝试。

上面代码中，如果await操作成功，就会使用break语句退出循环；如果失败，会被catch语句捕捉，然后进入下一轮循环。

来源：[https://segmentfault.com/a/1190000017469670][https_segmentfault.com_a_1190000017469670]

[https_segmentfault.com_a_1190000017469670]: https://segmentfault.com/a/1190000017469670