Async 函数

一、什么是Async函数

async函数就是将 Generator 函数的星号（*）替换成async，将yield替换成await

例：（两者相互转换）

//Generator函数表示
	const gen = function* () {
	  const f1 = yield readFile('/etc/fstab');
	  const f2 = yield readFile('/etc/shells');
	  console.log(f1.toString());
	  console.log(f2.toString());
	};

//async函数表示
	const gen = async function () {
	  const f1 = await readFile('/etc/fstab');
	  const f2 = await readFile('/etc/shells');
	  console.log(f1.toString());
	  console.log(f2.toString());
	};

二、async函数的语法

1、返回 Promise 对象

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

例：

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

运行结果：

async函数内部抛出错误，会导致返回的 Promise 对象变为reject(失败)状态。抛出的错误对象会被catch方法回调函数接收到。

例：

	async function f() {
	    throw new Error('服务器报错！')
	}
	
	f().then(v => alert(v)).catch(err=>alert(err.message))

运行结果：

2、await 命令

await命令后面是一个 Promise 对象，返回该对象的结果。

例：

    function timeOutOne() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get one number')
                resolve(1000)
            }, 3000)
        })
    }

    function timeOutTwo() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get two number')
                resolve(100)
            }, 3000)
        })
    }


    async function f() {
        let one = await timeOutOne();
        let two = await timeOutTwo();
        return one + two
    }

    f().then((v) => alert(v)).catch(err => alert(err.message))

运行结果：

await命令后面如果不是 Promise 对象，就直接返回对应的值。

例：

	async function f() {
        let one = await 1000;
        let two = await 2000;
        return one + two
    }

    f().then((v) => alert(v)).catch(err => alert(err.message))

运行结果：

await命令后面的 Promise 对象如果变为reject（失败）状态，则reject的参数会被catch方法的回调函数接收到，并且整个async函数都会中断执行。

例：

	async function f() {
        await Promise.reject('async 函数已经停止了');
        await Promise.resolve('hello world');
    }

    f().then((v) => alert(v)).catch(err => alert(err.message))

运行结果：

我们希望即使前一个异步操作失败，也不要中断后面的操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，后面的代码都会执行。

例：

	async function f() {
        try {
            await Promise.reject('async 函数已经停止了');
        }catch (e) {
            console.log(e)
        }
        console.log('change')
       
    }
    
    f()

运行结果：

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

例：

	async function f() {

        await Promise.reject('async 函数已经停止了').catch(e => console.log(e));
        console.log('change')
    }

    f()

运行结果：

3、Promise 对象的状态变化

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

	function timeOutOne() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get one number')
                resolve(1000)
            }, 3000)
        })
    }

    function timeOutTwo() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get two number')
                resolve(100)
            }, 3000)
        })
    }


    async function f() {
        await timeOutOne()
        await timeOutTwo()
        console.log('get last number')
    }

    f()

运行结果：

三、注意事项

1、await命令后面的Promise对象，运行结果可能是rejected（失败），所以最好把await命令放在try...catch代码块中。

2、多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发。

例：（继发关系）

    function timeOutOne() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get one number')
                resolve(1000)
            }, 6000)
        })
    }

    function timeOutTwo() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get two number')
                resolve(100)
            }, 3000)
        })
    }

    async function f() {
        await timeOutOne()
        await timeOutTwo()
    }

    f()

运行结果：

例：（同时触发）

    function timeOutOne() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get one number')
                resolve(1000)
            }, 6000)
        })
    }

    function timeOutTwo() {
        return new Promise(function (resolve, reject) {
            setTimeout(() => {
                console.log('get two number')
                resolve(100)
            }, 3000)
        })
    }

    async function f() {
        await Promise.all([timeOutOne(),timeOutTwo()])
    }

    f()

运行结果：

3、await命令只能用在async函数之中，如果用在普通函数，就会报错。