Promise (IV)

Promise Several key issues

1. If the current Promise Status as pending state , After throwing an exception ,Promise Will become rejected state

        const p6 = new Promise((resolve, reject) => {
            //resolve(1) //promise Turn into resolved Success status 
            // reject(2) //promise Turn into rejected Failure status 
            throw 3 // Throw an exception ,Promise Turn into rejected state ,reason  For the thrown error
        })
        p6.then(() => {
            value => {},
                reason => {
                    console.log('reason',reason)
                }
        })

2. One Promise More than one success was specified / Failed callback function , Are they called ？

// Multiple calls will all call back

        p6.then(() => {
            value => {
                console.log('success',value)
            },
                reason => {
                    console.log('reason',reason)
                }
        })
        p6.then(() => {
            value => {
                console.log('success',value)
            },
                reason => {
                    console.log('reason',reason)
                }
        })

3. change Promise State and specify the callback function who comes first and then ？

        // routine ： First specify the callback function , Changed state after 
        new Promise((resolve, reject) => {
            setTimeout(() => { // Changed state after ( Also specify the data , Asynchronously executing callback functions )
                resolve(1)
            })
        }).then(() => { // First specify the callback function , Saves the currently specified callback function 
            value => {},
                reason => {
                    console.log('reason', reason)
                }
        })

        // Method 1： Change the state first , In the specified callback function 
        new Promise((resolve, reject) => {
            resolve(1) // Change your state first （ Also specify the data ）
        }).then(() => { // After the specified callback function , Asynchronously executing callback functions 
            value => {
                    console.log('value', value)
                },
                reason => {
                    console.log('reason', reason)
                }
        })
        // Method 2： Change the state first , In the specified callback function 
        const ps = new Promise((resolve, reject) => {
            setTimeout(() => { // Changed state after ( Also specify the data , Asynchronously executing callback functions )
                resolve(1)
            },1000)
        })
        setTimeout(()=>{
         p.then(() => { // First specify the callback function , Saves the currently specified callback function 
            value => {},
            reason => {
               console.log('reason', reason)
                }
        })
        },1000)

Be careful ： stay Promise in , Successful and failed callback functions , Always asynchronous execution . Even if the conditions are met , Not immediately .

4.Promise.then Returned new Promise What determines the outcome status of ？

        //(1) Simple expression ： from then() Returned new Promise The result of the execution of the callback function determines 
        //(2) Detailed expression ：
                // If an exception is thrown , new Promise Turn into rejected,reason Exception thrown for 
                // If yes or no is returned Promise Any value of , new Promise Turn into resolved,value For the return value 
                // If you return another new Promise, this Promise The result will become new Promise Result 
            
        new Promise((resolve, reject) => {
            resolve(1)
            // reject(2)
        }).then(
            value => {
                console.log('onResolved1()', value)
                //return 2
                //return Promise.resolve(3)
                //return Promise.rekect(4)
            },
            reason => {
                console.log('onrejected1()', reason)
            }
        ).then(
            value => {
                console.log('onResolved2()', value)
            },
            reason => {
                console.log('onrejected2()', reason)

            }
        )