Promise -- several key problems

One 、 How to change promise The state of

1、 call resolve, The status changes to resolved

2、 call reject, The status changes to rejected

3、throw, The status changes to rejected

Two 、promise More than one success was specified / Failed callback function , Whether it will call

promise On the implementation , Will save multiple callback functions , That is, it will call

// The same promise p, When its state changes to resolved after ,1 and 2 They all print 
p.then(
    value=> {
        console.log(1)
    },
    reason=> {

    }
)
p.then(
    value=> {
        console.log(2)
    },
    reason=> {

    }
)

3、 ... and 、 change promise Status and specified callback function , Whoever first after ？

Fine , such promise Asynchronous processing is more flexible to use

// The code in the body of the executor function is synchronized 
//1、 Change the state first , Specify callback after 
new Promise((resolve,reject)=>{
    resolve(1)
}).then(
    value=>{},
    reason=>{},
)

//2、 Specify callback first , Post change state 
new Promise((resolve,reject)=>{
    setTimeout(()=>{
        resolve(1)
    },1000)
}).then(
    value=>{},
    reason=>{},
)

Four 、promise.then() Back to the new promise What determines the outcome status of ？

1、 Put it simply ： from then() Callback function executed in , The results of the implementation determine

2、 Detailed description ：

a、 Throw an exception , new promise Turn into rejected The state of ,reason Exception thrown for

b、 If yes or no is returned promise, new promise Turn into resolved state ,value by return Value

c、 If you return a promise, this promise The result will be new promise Result

5、 ... and 、promise Abnormal transmission of

p.then(
    value=>{},
    // There are no failed callbacks written here , The following code will be automatically added 
    //reason=>{throw reason}  perhaps  reason=> Promise.reject(reason)
).then(
    value=>{},
    // There are no failed callbacks written here , The following code will be automatically added 
    //reason=>{throw reason}  perhaps  reason=> Promise.reject(reason)
).catch(
    reason=>{}
)

1、promise Abnormal transmission refers to , When using promise Of then Chain call , Even if not in then Failed callback function specified in , You can also specify the failed callback at the end , Use catch.

2、 Exception in any previous operation , Not handled halfway , Will reach the last catch in

6、 ... and 、 How to interrupt promise Chain call of

1、 Need to know ：catch Then you can continue then

p.catch(
    reason=>{}
).then(
    value=>{},
    reason=>{},
)

2、 How to operate , interrupt promise Chain call of

Returns a... In the body of the callback function being executed pending State of promise

return new Promise(()=>{})