Promise、async、await

function a(){
    return 'a'
}
function b(){
    //return 'b'
    setTimeout(()=>{
        return 'b'
    },3000)
}
function c(){
    return 'c'
}
function run(){
    cc.log(a())
    cc.log(b())
    cc.log(c())
}

对于上面的代码，执行run()函数后发现：

a()和c()不会等到b()执行完再一起输出

这样b()就只会返回undefine

当我们在b()中使用promise后：

function b(){
    //return 'b'
    // setTimeout(()=>{
    //     return 'b'
    // },3000)
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            resolve('b')
        },3000)
    })
}

结果：

undefine变成了Promise（pending的状态），所以promise可以用来处理一些异步任务，解决异步写法中的嵌套问题（回调地狱）

异步任务会在当前的同步任务都处理完成之后在执行。

• 待定（pending）: 初始状态，既没有被兑现，也没有被拒绝。

• 成功（fulfilled）: 意味着操作成功完成。

• 失败（rejected）: 意味着操作失败。

 async和await可以让b()实现完c()再实现：

function a(){
    return 'a'
}
function b(){
    //return 'b'
    // setTimeout(()=>{
    //     return 'b'
    // },3000)
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            resolve('b')
        },3000)
    })
}
function c(){
    return 'c'
}
async function run(){
    cc.log(a())
    cc.log(await b())
    cc.log(c())
}

结果：

由此可知：async和await可以使让b()执行完之后再去执行c()

promise中的resolve，reject参数：

resolve可以理解为成功时候的一个工具，reject是失败时候要使用的一个工具，每个promise都具备一个状态的概念，像pending、fulfilled、rejected。

在开发过程中，无论是同步和异步任务，执行过后都会有成功、失败，取决于代码的逻辑，比如向服务端请求一个数据，如果我拿到的是正确的数据，那这就是成功的，

如果给服务端的身份认证信息没有通过，或者请求次数过多，或者服务端觉得参数有问题，会给你返回一个失败的信息，意味着后续操作是不能执行的，这就是失败的状态。

那在请求的过程中，可能因为网速慢等原因，信息没有返回，就判定不了成功和失败，处于pending的状态。

使用resolve，reject：

resolve() 是一个函数对象方法，意味着只能用在函数对象 Promise 上。它接收一个 value 参数，返回一个这个给定值解析后的 Promise 对象。

reject() 方法返回一个失败的 Promise 对象，接收一个 value 参数，表示失败的原因。

语法：

        const p1 = new Promise((resolve,reject)=>{
            resolve('成功')
            reject('失败')
        })

那‘成功’‘失败’这些参数要怎么用呢？

Promise提供了then 方法和catch方法来分别处理resolve()、reject()，都绑定在原型 prototype 上，意味着是一个实例方法，必须在实例对象上才能使用：

resolve():

        const p1 = new Promise((resolve,reject)=>{
            resolve('成功')
            //reject('失败')
        })
        p1.then(data=>{
            cc.log(data);
        })

reject(): 

        const p1 = new Promise((resolve,reject)=>{
            //resolve('成功')
            reject('失败')
        })
        p1.then(data=>{
            cc.log(data);
        })
        .catch(data=>{
            cc.log(data)
        })

因为Promise返回resolve()之后会触发then方法，返回reject()之后会触发catch方法，所以上面运行之后分别会输出‘成功’、‘失败’，

异步任务分解：

promise可以有效地减少嵌套的总层数，p1.then().then()哪怕里面有再多的异步任务，也只是在一层里面：

        const p1 = new Promise((resolve,reject)=>{
            resolve('成功1')
            //reject('失败')
        })
        p1.then(data=>{
            cc.log(data);
            return new Promise((resolve,reject)=>{
                resolve('成功2')
            })
        })
        .then(data=>{
            cc.log(data);
        })

结果：