aysn和await

声明：1.解决异步调用的写法和同步保持一致。

           2.async是声明获取异步调用结果的函数，而await是声明在async函数中获取异步调用的结果的语句。

           3.异步调用一般返回为promise，async执行完也会返回promise。

例1：

function A(guess){
    return new Promise((resolve, reject)=>{
        let sino = parseInt(Math.random() * 6 +1)
        if(sino > 3){
            if(guess === '大'){
                resolve(sino)
            }else{
                reject(sino)
            }
        }else{
            if(guess === '大'){
                reject(sino)
            }else{
                resolve(sino)
            }
        }

        setTimeout(()=>{
            resolve('hello')
        },3000)
    })
}
async function test(){
    try{
        //把await及获取它的值的操作放在try里
        let n =await A('大')
        console.log('赢了' + n)
    }catch(error){
      //失败的操作放在catch里
        console.log('输了' + error)
    }
}
test()
//输了1

 解析：await会等待异步调用的结果，获取到调用结果之后进行向下执行同步语句。正常返回时promise中的resolve(n)， 异常返回为promise重的reject(n),它只接受一次resolve和reject，promise中的第二次resolve或者reject不接受。如果要获取多个异步调用的结果，使用Promise.all。

例2：

async function test(){
    try{
        //把await及获取它的值的操作放在try里
        let n =await Promise.all([A('大'),A('大')])
        console.log('赢了' + n)
    }catch(error){
      //失败的操作放在catch里
        console.log('输了' + error)
    }
}
//赢了4,5 获取输了3

promise.all里面跟一个数组，数组的每一项是一个返回promise的函数调用，then的第一个参数是所有的promise都成功后调用，拿到所有promise的结果是一个数组；

第二个参数拿到的是第一个失败的值。

async执行完也会返回promise，而且promise中的resolve的值为async函数的返回值，没有返回即为undefined。
例子3：

async function f1() {
  console.log('1');
//   return ('1')
}
console.log(f1()) //Promise { undefined }

例子4：

async function f1() {
  console.log('1');
  return ('1')
}
console.log(f1()) //Promise { '1' }

例子5：

async function f1() {
  console.log('1');
  return ('1')
}
f1().then(function(x1) {console.log('x1=',x1)}) //x1=1

 如何await等待的不是promise对象，则立即获取返回，继续向下执行。

例子6：

function getN(){
    // 如果是同步代码，则按照同步顺序代码执行。
    setTimeout(function(){
        console.log('返回的不是promise') //4
        return 4
    },2000)
}
async function test(){
    console.log('我在test中执行') //1  在await之前都是同步执行1
    var n = await getN();
    console.log(n);  //undefined,因为返回的不是promise.
}
test();
console.log('先执行我，然后执行await') //2
//我在test中执行
//先执行我，然后执行await
//undefined
// 返回的不是promise

如果它等到的是一个 promise 对象，await 也会暂停async后面的代码，先执行async外面的同步代码，等着 Promise 对象 fulfilled，然后把 resolve 的参数作为 await 表达式的运算结果。

例子7：

function getN(){
    return new Promise((resolve, reject) => {
        setTimeout(function(){
            console.log('返回的不是promise') //3
            resolve(4)
        },2000)
    })
   
}
async function test(){
    console.log('我在test中执行') //  在await之前都是同步执行1
    var n = await getN();
    console.log(n);  //4
}
test();
console.log('先执行我，然后执行await') //2
// 我在test中执行
// 先执行我，然后执行await
// 返回的不是promise
// 4

 如果promise没有返回值，则await会阻碍后面的代码执行：

例子8：

function getN(){
    return new Promise((resolve, reject) => {
        console.log('hello')
    })
}
async function test(){
    console.log('我在test中执行') //  在await之前都是同步执行1
    await getN();
    console.log('不会执行');  //4
}
test();
console.log('先执行我，然后执行await') //2
//我在test中执行
//hello
//先执行我，然后执行await

另外，当出现await预计之后：和promise中的then的执行一样，结束！