1. 关键问题1

1.  如何改变promise的状态?<br />      (1)resolve(value): 如果当前是pendding就会变为resolved<br />      (2)reject(reason): 如果当前是pendding就会变为rejected<br />      (3)抛出异常: 如果当前是pendding就会变为rejected<br />    <br />    2.  一个promise指定多个成功/失败回调函数, 都会调用吗?<br />      当promise改变为对应状态时都会调用

    const p = new Promise((resolve, reject) => {
      // resolve(1) // promise变为resolved成功状态
      // reject(2) // promise变为rejected失败状态
      // throw new Error('出错了') // 抛出异常, promse变为rejected失败状态, reason为 抛出的error
      throw 3 // 抛出异常, promse变为rejected失败状态, reason为 抛出的3
    })
    p.then(
      value => {},
      reason => {console.log('reason', reason)}
    )
    p.then(
      value => {},
      reason => {console.log('reason2', reason)}
    )

2. 关键问题2

/* <br />    3.改变promise状态和指定回调函数谁先谁后?<br />      (1)都有可能, 正常情况下是先指定回调再改变状态, 但也可以先改状态再指定回调<br />      (2)如何先改状态再指定回调?<br />        ①在执行器中直接调用resolve()/reject()<br />        ②延迟更长时间才调用then()<br />      (3)什么时候才能得到数据?<br />        ①如果先指定的回调, 那当状态发生改变时, 回调函数就会调用, 得到数据<br />        ②如果先改变的状态, 那当指定回调时, 回调函数就会调用, 得到数据<br />    */<br />    // 常规: 先指定回调函数, 后改变的状态

    new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1) // 后改变的状态(同时指定数据), 异步执行回调函数
      }, 1000);
    }).then(// 先指定回调函数, 保存当前指定的回调函数
      value => {},
      reason => {console.log('reason', reason)}
    )

    // 如何先改状态, 后指定回调函数
    new Promise((resolve, reject) => {
      resolve(1) // 先改变的状态(同时指定数据)
    }).then(// 后指定回调函数, 异步执行回调函数
      value => {console.log('value2', value)},
      reason => {console.log('reason2', reason)}
    )
    console.log('-------')

    const p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1) // 后改变的状态(同时指定数据), 异步执行回调函数
      }, 1000);
    })

    setTimeout(() => {
      p.then(
        value => {console.log('value3', value)},
        reason => {console.log('reason3', reason)}
      )
    }, 1100);

3. 关键问题3

/* <br />    4.  promise.then()返回的新promise的结果状态由什么决定?<br />      (1)简单表达: 由then()指定的回调函数执行的结果决定<br />      (2)详细表达:<br />          ①如果抛出异常, 新promise变为rejected, reason为抛出的异常<br />          ②如果返回的是非promise的任意值, 新promise变为resolved, value为返回的值<br />          ③如果返回的是另一个新promise, 此promise的结果就会成为新promise的结果 <br />    */

    new Promise((resolve, reject) => {
      // resolve(1)
      reject(1)
    }).then(
      value => {
        console.log('onResolved1()', value)
        // return 2
        // return Promise.resolve(3)
        // return Promise.reject(4)
        throw 5
      },
      reason => {
        console.log('onRejected1()', reason)
        // return 2
        // return Promise.resolve(3)
        // return Promise.reject(4)
        throw 5
      }
    ).then(
      value => {
        console.log('onResolved2()', value)
      },
      reason => {
        console.log('onRejected2()', reason)
      }
    )

4.关键问题4（串联多个任务）

/* <br />    5.promise如何串连多个操作任务?<br />      (1)promise的then()返回一个新的promise, 可以开成then()的链式调用<br />      (2)通过then的链式调用串连多个同步/异步任务<br />    */

    new Promise((resolve, reject) => {
      setTimeout(() => {
        console.log("执行任务1(异步)")
        resolve(1)
      }, 1000);
    }).then(
      value => {
        console.log('任务1的结果: ', value)
        console.log('执行任务2(同步)')
        return 2
      }
    ).then(
      value => {
        console.log('任务2的结果:', value)

        return new Promise((resolve, reject) => {
          // 启动任务3(异步)
          setTimeout(() => {
            console.log('执行任务3(异步))')
            resolve(3)
          }, 1000);
        })
      }
    ).then(
      value => {
        console.log('任务3的结果: ', value)
      }
    )

5. 关键问题5:promise异常传透/中断Promise链

6.promise异常传/穿透?<br />      (1)当使用promise的then链式调用时, 可以在最后指定失败的回调, <br />      (2)前面任何操作出了异常, 都会传到最后失败的回调中处理<br />    7.中断promise链?<br />      (1)当使用promise的then链式调用时, 在中间中断, 不再调用后面的回调函数<br />      (2)办法: 在回调函数中返回一个pendding状态的promise对象<br />   

    new Promise((resolve, reject) => {
      // resolve(1)
      reject(1)
    }).then(
      value => {
        console.log('onResolved1()', value)
        return 2
      },
      // reason => {throw reason}
    ).then(
      value => {
        console.log('onResolved2()', value)
        return 3
      },
      reason => {throw reason}
    ).then(
      value => {
        console.log('onResolved3()', value)
      },
      reason => Promise.reject(reason)
    ).catch(reason => {
      console.log('onReejected1()', reason)
      // throw reason
      // return Promise.reject(reason)
      return new Promise(() => {}) // 返回一个pending的promise  中断promise链
    }).then(
      value => {
        console.log('onResolved3()', value)
      },
      reason => {
        console.log('onReejected2()', reason)
      }
    )