js進階--Promise-10

Promise

Promise是es6新增的一個類
用處：將非同步程式碼，以同步的方式寫出來，避免了回撥地獄
使用的時候要new一下Promise

new的時候裡面傳一個函式，函式有兩個形參,第一個代表成功，第二個代表失敗

let p1=new Promise((resolve,reject)=>{
    resolve();//假設第一個函式執行
    reject();//第二個代表失敗
});

Promise有三個狀態

• pending等待態 fulfilled成功態 rejected失敗態
• Promise在new的時候立即執行,如果不指定狀態的話,預設為等待態pending
• 狀態只能改變一次，要麼pending–>fulfilled或者pending–>rejected
• 如果寫了reject也寫了resolve只執行前面的,因為狀態只能改變一次

resolve代表成功執行，reject代表失敗執行

then

例項.then()
then裡面可以放兩個函式，第一個是成功

p1.then(()=>{
    console.log("成功")
    // resolve執行，那這個就執行
},()=>{
    //reject執行，那這個就執行
    console.log("失敗")
})

前面的.then裡return如果不是promise例項的話，那麼會把return的東西當實參傳遞給下一個.then

catch

catch是promise原型上的一個方法，當任何一個promise的例項是失敗態的時候就會執行catch函式
如果回撥函式執行的時候發生了錯誤，那當前promise的例項會預設為失敗態
catch裡面的形參會接受報錯內容，或者失敗態的實參

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功態")
},()=>{
    console.log("失敗態")
})//"失敗態"

特殊情況
只要下面的then有失敗態的函式，就先執行失敗態的函式，沒有才執行catch

let p1=new Promise((res,rej)=>{
    res();
});

p1.then((res)=>{
    console.log(res,100);
    return new Promise((res,rej)=>{
        rej(111);
    })
}).then(()=>{},()=>{})
.catch((res)=>{
    console.log(res,200);
}).finally(()=>{
    console.log("最後")
})
//undefined 100  111 200 最後

let p1=new Promise((res,rej)=>{
    res();
});

p1.then((res)=>{
    console.log(res,100);
    return new Promise((res,rej)=>{
        rej(111);
    })
}).then(()=>{},()=>{})
.catch((res)=>{
    console.log(res,200);
}).finally(()=>{
    console.log("最後")
})
//undefined 100 最後

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功態")
},()=>{
    console.log(c)//讓他出錯
}).catch((aa)=>{console.log(aa,200)})//ReferenceError: c is not defined at <anonymous>:7:17 200

finally

除非為等待態，否則不論成功失敗，都會執行finally
finally方法的回撥函式不接受任何引數

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功態")
},()=>{
    console.log("失敗態")
}).catch((error)=>{console.log(error)}).finally(()=>{console.log(888)})//失敗態 888

Promise.all([])

• all裡面的陣列可以放promise例項，等裡面的全部執行完畢，會返回一個態度(成功態，或失敗態),陣列內全部成功all才返回成功態，有一個失敗就位失敗態
• 如果all為成功態，那麼陣列內所有promise的例項的返回值會傳遞給.then裡面的成功態，如果失敗，會把第一個失敗的傳參傳遞給.then裡的失敗態
  Promise.all的引數不一定是promise的例項，是別的值也可以，他內部會把當前的值轉換成成功態的promise例項

let p1=new Promise((resolve,reject)=>{
    resolve(100);
})
let p2=new Promise((resolve,reject)=>{
    resolve(200);
})
let p3=new Promise((resolve,reject)=>{
    resolve(300);
})
const p=Promise.all([p1,p2,p3]);
p.then((res)=>{
    console.log(res,"成功態")// (3) [100, 200, 300] "成功態"
},(rej)=>{
    console.log("失敗態")
})

Promise.race([])

[]裡的promise例項中誰先執行完畢，那麼這個先執行完成的是什麼態那就是什麼態(成功，失敗，等待)，返回值也只接收這一個,如果為等待態，那麼就不執行.then

let p1=new Promise((resolve,reject)=>{
    setTimeout(()=>{    resolve(100);},1000)
})
let p2=new Promise((resolve,reject)=>{
    // resolve(200);
    setTimeout(()=>{},100)
})
let p3=new Promise((resolve,reject)=>{
    // resolve(300);
})
const p=Promise.all([p1,p2,p3]);
p.then((res)=>{
    console.log(res,"成功態")
},(rej)=>{
    console.log("失敗態")
})
//Promise {<pending>}

Promise.resolve()

他的返回值就是一個已經成功的promise的例項

let pp=Promise.resolve(100);
let pp=new Promise((res,rej)=>{
    res(100);
})
//兩者相等

Promise.reject()

他的返回值就是一個已經失敗的promise的例項

let pp=Promise.reject(100);
let pp=new Promise((res,rej)=>{
    rej(100);
})
//兩者相等