为什么要用promise

  promise相对于纯回调的优点:

  1. 指定回调方式更加灵活

    旧的: 必须在启动异步任务前指定回调函数

    promise:启动异步任务=>返回promise对象=>给promise对象绑定回调函数(甚至可以在异步结束后指定)

  2. 支持链式调用,解决回调地狱

    什么是回调地狱?

　回调函数嵌套调用,外部回调函数异步执行的结果是嵌套的回调函数执行的条件

    第二个异步任务是以第一个异步任务成功为前提

    回调地狱的缺点?不便于阅读/不便于异常处理

    解决方案:promise链式调用(虽然没有了嵌套,但是还有回调函数)

    终极解决方案?async/await

   // 成功的回调函数
    function successCallback(result) {
      console.log('声音文件创建成功' + result)
    }
    // 失败的回调函数
    function failureCallback(error) {
      console.log('声音文件创建失败' + error)
    }

    /* 1.1 纯回调函数 */
    //启动任务(audioSettings)前必须指定回调函数(callback)
    createAudioFileAsync(audioSettings, successCallback, failureCallback)

    /* 1.2 promise */
    //可在启动任务(audioSettings)后指定回调函数(callback)
    const promise = createAudioFileAsync(audioSettings)
    setTimeout(() => {
      promise.then(successCallback, failureCallback)
    }, 1000)



    /* 2.1 回调地狱 */
    //回调函数的嵌套
    doSomething(function (result) { //第一个函数function就是sucessCallback成功回调
      doSomethingElse(result, function (newResult) {
        doThirdThing(newResult, function (finalResult) {
          console.log('Got the final result' + finalResult)
        }, failureCallback)
      }, failureCallback)
    }, failureCallback)


    /* 2.2 链式调用 */
    doSomething().then(function (result) { //result是doSomething函数成功执行的返回值
      return doSomethingElse(result)      //执行器函数,同步回调
    })
      .then(function (newResult) {  //newResult是doSomethingElse成功执行的返回值
        return doThirdThing(newResult)
      })
      .then(function (finalResult) {
        console.log('Got the final result' + finalResult)
      })
      .catch(failureCallback) //统一的错误处理(异常传透)


    /* 2.3 async/await : 回调地狱的终极解决方案 */
    //根本上去掉回调函数
    async function request() {
      try {
        const result = await doSomething()
        const newResult = await doSomethingElse(result)
        const finalResult = await doThirdThing(newResult)
        console.log('Got the final result' + finalResult)
      } catch (error) {
        failureCallback(error)
      }
    }