概念:
promise是为了解决异步问题而诞生的
目的:
为了解决异步任务而诞生,可以将一个异步的流程变为同步的
promise有三种状态：
promise — 会将函数的状态暂停(凝聚,冻结)
resolve — 处理成功的情况
reject — 处理失败的情况
promise不会直接触发,它会通过(then,catch)才会触发

    1.触发promise的resolve状态,可以then函数去触发<br />        2.触发reject状态,通过catch函数去触发

        var p = new Promise((resolve, reject) => {
            // resolve(1);
            reject(2);
        })
        p.then(res=>{
            console.log(res)
        }).catch(err=>{
            console.log(err)
        })

1.async

在函数前面加上async,那么函数的返回值就是有一个promise

        async function go() {
            return 10;
        }

得到promise的执行结果
1.then
2.await (但是只能在async函数中使用,后面只能是promise)

2.await

        async function getResult(){
            var res = await go();
            console.log(res)
        }
        getResult()

3.promise-ajax

function http(url){
    return new Promise((resolve,reject)=>{
        $.ajax({
            url:`http://192.168.4.18:3000/${url}`,
            type:"get",
            success:res=>{
                resolve(res)
            },
            error:err=>{
                reject(err)
            }
        })
    })
}

        http("top/playlist/?cat=华语").then(res=>{
            let id = res.playlists[0].id;
            return id;
        }).then(res=>{
            let id  = res
            http(`playlist/detail?id=${id}`).then(res=>{
                var {name,id} = res.playlist.tracks[0]
                console.log(id);
            })
        })

-

function http(url){
    return new Promise((resolve,reject)=>{
        $.ajax({
            url:`http://192.168.4.18:3000/${url}`,
            type:"get",
            success:res=>{
                resolve(res)
            },
            error:err=>{
                reject(err)
            }
        })
    })
}

        /* 
        top/playlist/?cat=华语
        playlist/detail?id=${id}
         */
        async function go(){
             var res = await http("top/playlist/?cat=华语");
             var id = res.playlists[0].id;
             var detail  =await http(`playlist/detail?id=${id}`);
             console.log(detail)
        }
        go()

4.异步的终极解决方案

        /* promise,async,await */
        var a = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(1)
            }, 2000)
        })
        var b = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(2)
            }, 1000)
        })
        /* async await */
        /* 
        promise函数执行
        1.then
        2.在async函数中,通过await语句去执行
         */
        function go(){
           var res = await a;
           console.log(res)
           var sum = await b;
           console.log(sum);
        }
        /* 在函数前面加上async
        1.这个函数的返回值就是promise
        2.可以在函数中使用await关键字
         */
        go()
        /* 
        await可以得到promise的执行结果,await语句后面只能是promise
         */