关于async、await何时同步，何时异步执行的问题

 const p = new Promise((resolve,reject)=>{
            const num = 10
            setTimeout(()=>{
                if(num > 5) resolve('success')
                else reject('lose')
            },1000)
        })
        const p1 = new Promise((resolve,reject)=>{
            const num = 10
            setTimeout(()=>{
                if(num > 5) resolve('success1')
                else reject('lose1')
            },2000)
        })
        const p2 = new Promise((resolve,reject)=>{
            const num = 3
            setTimeout(()=>{
                if(num > 5) resolve('success2')
                else reject('lose2')
            },3000)
        })

        const fn = async () => {
            const res = await p
            console.log(res)       // 这句会等 p 异步执行完
            console.log('haha')    // 这句会等 p 异步执行完

            const res1 = await p1  // p 和 p1 是同时开始执行的，也就是说 p1 并不会等 p 异步执行完再开始执行
            console.log(res1)      // 这句会等 p1 异步执行完
            console.log('hehe')    // 这句会等 p1 异步执行完

            const res2 = await p2  // p2也是和p、p1同时开始执行的，但p2失败了，所以用await时捕捉失败要用try-catch
            console.log(res2)      // p2失败了，所以这句不执行
        }

        fn()

        // 综上所述，在没有依赖关系的情况下，所有的异步代码都是同步执行（同时开始执行）的

// const p = new Promise((resolve,reject)=>{
        //     const num = 10
        //     setTimeout(()=>{
        //         if(num > 5) resolve('success')
        //         else reject('lose')
        //     },1000)
        // })
        // const p1 = new Promise((resolve,reject)=>{
        //     const num = 10
        //     setTimeout(()=>{
        //         if(num > 5) resolve('success1')
        //         else reject('lose1')
        //     },1000)
        // })

        // const p2 = new Promise((resolve,reject)=>{
        //     const num = 3
        //     setTimeout(()=>{
        //         if(num > 5) resolve('success2')
        //         else reject('lose2')
        //     },3000)
        // })

        // 如何实现异步执行完 p 之后，再异步执行 p1  ？


        // const fn = async () => {
        //     const res = await p
        //     console.log(res)
        //     fn1()
        // }
        // const fn1 = async () => {
        //     const res = await p1
        //     console.log(res)
        // }
        // fn()


        // 以上方法行不通，你会发现仍然是同步的，因为你p1的异步执行并没有依赖p执行成功后的结果
        // 试一下有依赖关系的效果：

        const p = new Promise((resolve,reject)=>{
            const num = 10
            setTimeout(()=>{
                if(num > 5) resolve('success')
                else reject('lose')
            },1000)
        })

        const fn1 = (res) => {
            const p = new Promise((resolve,reject)=>{
                const num = 10
                setTimeout(()=>{
                    if(num > 5) resolve('success1 '+res)
                    else reject('lose1')
                },1000)
            })
            return p
        }
        
        const fn = async () => {
            const res = await p
            console.log(res)
            const Res = await fn1(res)
            console.log(Res)
        }
        fn()

        // 综上所述，在有依赖关系的时候代码才会“等”上面的异步执行完 再 异步执行下面的，这也是promise, async-await出现的初衷：解决回调地狱