Promise的几个关键问题

Promise的几个关键问题

1、如何改变Promise的状态？

（1）resolve（value）：如果当前是pendding会变为resolved

（2）reject（value）：如果当前是pendding会变为rejected

（3）抛出异常：throw任意值，不光是error都能使promise的pendding状态变为rejected状态，如果抛出的是new Error（error），那么得到的promiseValue就是error。抛出普通值那么对应的promiseValue就是抛出的值。

注意：一个promise的状态只能改变一次

2、一个promise指定多个成功或者失败的回调函数，都会调用吗？

当promise改变为对应的状态时都会调用。

3、改变Promise的状态和制定回调函数谁先谁后

这个实际上是都有可能的**，正常情况下（一般逻辑）是现指定回调再改变promise状态。但也可以先改变状态在指定回调。**

		new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(1)
            }, 1000);
        }).then(
            value => { },
            reason => { }
        )

比如这段代码，因为setTimeout这个函数是异步执行的，因此他是在then方法指定回调后在执行去改变promise的状态（同时指定数据）的。因为就算我们先是指定了回调函数，如果状态没有改变，这会儿是不会调用的，是先将回调函数存起来，等待状态改变后再异步调用对应的回调函数。

		new Promise((resolve, reject) => {
                resolve(1)
        }).then(
            value => { },
            reason => { }
        )
		//或者下面这种也是先改变状态再指定回调函数
		 const p = new Promise((resolve, reject) => {
                console.log("change state");
                resolve(1)
        })
        setTimeout(() => {
            p.then(
            value => { 
                console.log("callback is configured",value);
            },
            reason => {
                console.log(reason);
            }
         )
       }, 1000);
		//结果先是输出"change state"，又过了1秒钟输出"callback is configured" 1
		//这个就是先改状态后指定回调函数

这段代码没有异步操作，因此是在promise状态改变之后才指定的回调（但是我们实际开发中一般不这么用）。

4、Promise.then（）返回的新的promise的结果状态由什么决定？

1、简单表达：由.then( )内部指定的回调的执行结果决定（就是由onResolved或者onRejected的返回值决定）

3、详细表达：

​ （1）如果抛出异常，新的promise状态为rejected，reason为抛出的异常。

​ （2）如果返回（return）的是非promise的任意值，新的promise状态为resolved，value为返回的值。

​ （3）如果返回的是另一个新的promise，此promise的结果就会成为新的promise的结果。

举例子：

 const p = new Promise((resolve,reject)=>{
          resolve(1)   //这里不管是成功还是失败，then方法都会调用对应的回调，而下面的onResolved方法
     //和onResolved方法都没有指定返回值，因此返回的都是一个成功的、值为undefined的promise
     
        // reject(9)
        //throw new Error(4)
    }).then(		//先是得到一个成功的promise，然后调用then方法
        value=>{
            console.log(value);  //由于上一个promise是成功的，因此调用then方法中的指定成功的回调
            //这个回调函数并没有指定返回值return，因此默认返回undefined
        },
        reason=>{
            console.log(reason);
        },
    )
    console.log("p:",p); //得到的是一个值为undefined的成功的Promise（状态为resolved）
	 p.then(
        value=>{
            console.log(value); //由于p是一个成功的值为undefined的promise，
            //因此调用then方法中的指定成功的回调，value值就是undefined
        },
        reason=>{
            console.log(reason);
        },
    )

5、Promise如何串联多个操作任务？

​ （1）promise的then( )方法返回一个新的promise，这个promise又可以调then( )方法，形成then( )方法的链式调用，串联多个操作任务。

​ （2）通过then的链式调用串联多个异步（或者同步，不过一般没必要）任务。

下面代码演示如何串联多个同步或者异步的任务:

   const p = 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) => {  //返回一个新的promise
                    setTimeout(() => {
                        console.log("开始异步任务3");
                        resolve(3)
                    }, 1000);
                })
            }
        )
        console.log("p:",p);

执行结果如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TlTQKlQl-1585067569088)(C:\Users\joey\AppData\Roaming\Typora\typora-user-images\image-20200325000206732.png)]

6、Promise异常传透

​ （1）当Promise的then方法链式调用时，可以在最后指定失败的回调。

​ （2）前面任何出现了异常，都会传到最后失败的回调中处理。

代码分析：

		const p = new Promise((resolve, reject) => {
            reject(1)
        }).then(
            value => {
                console.log("任务1返回的结果是：", value);
                return 2
            },
           //  reason => {
           //  		throw reason
           // 	}
        ).then(
            value => {
                console.log("任务2返回的结果是：", value);
                return 3
            }
        ).then(
            value => {
                console.log("任务3返回的结果是：", value);
                return 4
            }
        ).catch(reason=>{
            console.log("失败了",reason);  //reason 1
        })

由于一开始就是一个失败的promise，所以他下面的then方法中的onResolved回调是不会被调用的，then方法中如果没有定义onRejected回调，那么promise内部就会执行这样的回调：

		reason => {
  		  throw reason
		}

这样子就实现了promise异常的传透，这也是为什么Promise的异常处理比纯回调的方式异步编程要方便得多。

注：如果在catch之前就已经有onRejected回调处理了异常，则不会传透到catch。

7、中断Promise链

​ （1）当使用promise的then方法链式调用时，在中间中断，不再调用后面的回调函数。

​ （2）办法：在回调函数中返回一个pendding状态的promise对象。

注：因为then方法中的回调执行时必须等待一个promise的结果的，如果我们不想再调用后面的回调函数，想要中断promise链，我们就可以返回一个pendding状态的promise，这样状态不改变，就不会调用onResolved或者onRejected，就完成了中断promise链。