当你付款完成后，就发出了对某个值（这里就是汉堡）的请求。此时店员就会给你一个东西代替汉堡，通常是带有编号的收据，那么收据上的编号就是你核销汉堡的凭证，这个编号也代表了汉堡店给你的承诺（promise），即，未来会给你一个汉堡。

此时有了收据，就可以等待（等待态）了，在等待的途中，你可以做其他的事情。

但是汉堡依旧在你的大脑中，你不会等到汉堡送来时产生“为什么给我个汉堡？”等其它疑惑，所以当汉堡送来时，你就会直接处理这个值（汉堡）——把它吃掉。

此时这个在大脑中的汉堡，你也可以理解为即将得到的汉堡，是一个“未来值”，即占住了位置，但并没有拿到实物进行处理，反而你正在做其他事。

等待片刻后，叫到了你的号码，你可以去领汉堡了。

此时会发生3种情况。

核对编号成功，完成交易，拿到汉堡。即，我需要的值（汉堡），已经处理好了，我拿承诺值（商家给的编号）换取这个值本身（汉堡）。此时，未来值成功了（得到汉堡了），结果就是你就开始吃汉堡了，吃饱了。
核对编号成功，汉堡卖完了。值（汉堡）没了，未来值（即将得到汉堡）失败了（汉堡并没得到），结果是你可能会换一个地方吃或者干别的。
商家系统故障，你的号永远都没被叫到。现实中有现实中的处理办法，但在程序中，这是一种未决议状态。

从上面的例子可以看出，核对编号到拿到/未拿到汉堡到最终是吃还是没吃的结果，这是一个完整的过程，重要的是最后的结果，是吃了还是没吃。

这基本诠释了使用Promise的整个流程，即Promise先决议，然后确定未来值的状态，有成功也有失败，成功后对应一种结果返回，失败后对应一种结果返回，且只会有一种结果被返回。

未决议状态会放在之后讨论。

Promise

Promise：从语义上可以看出，它是一个承诺，承诺一段时间后给你反馈一个结果，从语法上，它是一个对象，使用new来创建，它会有三种状态，等待pending、成功resolve、失败rejecte，且一旦状态确定，就无法更改，此时它成了不变值。

Promise创建的任务是微任务。

未决议状态会放在之后讨论，它不是主观触发的一种状态，而以上三种，是promise必备的状态。

此时你是否想到未来值，它也有成功/失败的状态。

所以说：Promise会很好的展现未来值的特性，是一种封装和组合未来值的易于复用的机制。

来看看Promise的使用语法。

let p1 = new Promise((resolve, reject) => {// resolve("成功");reject("拒绝");})

使用决议函数reject()表示失败（请求拒绝）。

使用决议函数resolve()表示成功。

注意，这里为了一次展示语法也为了代码能正常执行，我将resolve(“成功”)注释掉了，因为状态一旦确定就无法更改，如果没有注释，那意思就是，先成功，后又改为失败，这样是不行的，只能有一个状态存在，所以将其中一个注释掉。

使用new来创建的promsie是标准promise。

Promise内封装了“等待底层值的完成或拒绝”的状态，这个状态依赖于时间，所以是这个状态与时间有关，而promise本身与时间无关，可以得出：Promise可以按照可预测的方式进行组合，不用担心时序带来的变化或底层的结果。这可以避免很多传统异步的问题，之后我们会详细讨论。

同样的，Promise的状态不可更改会带来一些好处：

使用Promise决议过的值是不变值，外部无法进行更改，那么，将这个值传给第三方，或者多方进行观察，它就更加安全了，因为无法被修改。

由于状态不可更改，导致Promise产生的任务有以下特点：单一、不可逆、不可撤销，所以，一个Promise，不能有两种状态赋予。

单独的Promise展现了未来值的特性，但是，就像核销编号完成后拿到/未拿到汉堡所产生的结果例如：吃汉堡或换家店一样，Promise完成之后，会有一个东西来执行后面的事情，然后返回一些东西。

使用then()方法来执行得到成功/失败状态后的事情。

Then()

then()方法就像是promise的配套组件，每一个promise都会有一个对应的then()

then()方法内有两个参数，即两个方法，分别接收resolve()和reject()传递过来的“信号”，收到成功状态的信号，就传给then()的第一个函数value，收到失败状态的信号，就传给第二个参数reason，这里使用箭头函数，你可以使用其它函数方法和命名。

    new Promise((resolve, reject) => {resolve("操作成功，这是业务1");
// reject("拒绝状态，这是拒绝的业务处理 ");}).then(value => {console.log("成功业务处理 1");},reason => {console.log("拒绝的业务处理");})

这里注释掉了reject()，保留了resolve状态，所以传递到then()时就会执行value，输出“成功业务处理1”。

注意：promise对象有几个参数，就要给then()几个参数，即使是null。

一般是两个参数。

new Promise((resolve, reject) => {resolve("操作成功，这是业务1");
// reject("拒绝状态，这是拒绝的业务处理 ");})
.then(msg => {console.log("success:" + msg);},null）

这里对于reject状态并不想处理，所以没有处理方法，使用null，但不能没有，会报错。

没有null：

Promise不仅可以用于异步问题，还能用于很多地方，这些稍后会说，现在先考虑promise最基本的方法。

链式Promise

在正式开始说链式Promise之前，我们需要搞清楚三个概念。

每个then()都是一个Promise对象。
是否在promise中return。
每个then()会处理离自己最近的那个promise。

先来看看第一点。

1.每个then()都是一个Promise对象

let p1 = new Promise((resolve, reject) => {reject("rejected");});let p2 = p1.then(value => console.log(value),reason => console.log(reason))console.log(p2)

其中p2就是p1的then()，将它打印出来。

可以看到，它是一个准备态的promise。

对它的操作，要么就把它当作一个准备好的微任务并放入任务列表中，要么就将它看作一个promise，为它再配套一个then()，来对这个then()产生的结果再次进行处理。

let p1 = new Promise((resolve, reject) => {reject("rejected");});let p2 = p1.then(value => console.log(value),reason => console.log(reason)).then(//.then对上一个promise进行处理，即p1.thena => console.log("成功"),b => console.log(b));

第二个then()就在处理第一个then()了，可以看下运行结果。

let p1 = new Promise((resolve, reject) => {//resolve("fulfilled");reject("rejected");});let p2 = p1.then(value => console.log(value),reason => console.log(reason)).then(//.then对上一个promise进行处理，即p1.thena => console.log("成功"),b => console.log("失败"));

注意：两个then()之间不能插入任何的东西。

你觉得输出的结果会是什么？

先看下浏览器的结果，与你的理解可能会有偏差。

你会不会觉得第二个输出，应该是“失败”？为什么会是成功？不是reject从上到下传过来的吗？

注意：第二个then()是对上一个then()进行了处理，我们对现在的p2，也就是第一个then()进行输出，看下它的状态。

注意：由于宏任务，微任务，同步任务的关系，我们设置一个定时器来让输出语句在微任务之后进行，才能看到微任务执行后的结果。

let p1 = new Promise((resolve, reject) => {//resolve("fulfilled");reject("rejected");});let p2 = p1.then(value => console.log(value),reason => console.log(reason)).then(//.then对上一个promise进行处理，即p1.thena => console.log("成功"),b => console.log(b));setTimeout(() => {console.log(p2);});

可以看到p2的状态是“fulfilled”，也就是成功了，所以在第二个then()中，执行了a，输出“成功”。

原因：第二个then()处理的是第一个then()，第一个then()接收到起始promise的信号，并处理了它，它的处理过程是很成功的，所以它是成功的，它的状态与起始promise无关，所以在接下来的第二个then()处理它时，是按照成功的状态走的，所以执行成功。

那有没有什么办法，让我们自定义传给第二个then()的promise的状态。

当然可以。但是并不是简单的使用then()一直往下串，我们还是需要创建新的promise对象来重新赋予任务状态。

此时就要讨论第二点了，先看上个问题的解决办法。

2. 是否在promise中return

只需要在第一个then()当中新创建一个promise并且return它即可。

let p1 = new Promise((resolve, reject) => {resolve("fulfilled");}) .then(value => {return new Promise((resolve, reject) => {//只要return了，后面的then针对的就是这个return的新promise           reject("处理失败");})},reason => console.log(reason)).then(//此时的then是对上面的then的处理value => {console.log("成功:" + value);},reason => console.log("error" + reason));

在浏览器中查看结果。

起初的promise状态为resolve，所以执行value中的函数，value将新的promise返回，而这个新的promise的状态是reject，所以走到第二个then()中的reason(),打印出“erro处理失败”。

这个过程很像工厂的流水线，比如做面包，原料经过第一个机器，被做成面包胚，再经过第二个机器，被烤熟，最后的结果就是得到一个熟的面包，之前的原料和生面包胚都不复存在，没有人会在意它们，只会在意到手的面包。

但是，注意：第一个机器需要将面包胚吐出来，才能到下一个机器那里进行加工，这就是为什么要return这个promise的原因，我们需要将当前的promise进行返回，才能让下一个then()处理它。

有返回就有不返回，不返回会怎么样呢？

就像原料卡在机器里不出来一样，整个成产线都崩溃了，看看浏览器里的情况。

成功了是因为我们新建的promise并不影响整体流程，像之前说过的一样，经过一轮一轮then()的处理就行，那undefined呢？

Undefined和下一行错误息息相关，因为我们新建了promise却没有给它相对应的then()，所以这个promise是不能正常创建任务的，它什么都没有给下一个then()，但是它的状态是resolve()，所以是“成功：undefined”。

所以说，当你需要一步一步处理你的promise时，千万不要忘了return。

可是，并不总是需要处理标准的promise对象，就像一样的原料，我可以让它变成面包胚、披萨饼、或者其它的东西再传送出去一样，我们也可以返回其它的类型。

例如普通的对象和类。

先来看返回普通的对象。

let p1 = new Promise((resolve, reject) => {resolve("fulfilled");}).then(value => {return{//返回普通的对象name:"Cherrie"}},reason => {}).then(value => {console.log(value);console.dir(value);},reason => {console.log(reason);});

在浏览器里打印它。

对象就被返回出来了，你也可以使用它返回其他需要的类型，返回类，修改以上代码即可，这里不多赘述。

在这里强调它可以返回其它类型值的原因是，我们可以通过这个特点来返回除标准promise以外的其它类promise类型，也就是类似标准promise的promise类型，不是我们使用的class哦。

先看代码吧。

 .then(value => {return {then(resolve,reject){resolve("成功")}}},reason => {})

在这个then()中，我们返回一个对象，对象中有一个then()方法。

注意了，这个对象返回的可就不是普通对象了，它返回的是一个promise对象。

放上完整的代码来验证一下。

let p1 = new Promise((resolve, reject) => {resolve("fulfilled");}).then(value => {return {then(resolve,reject){resolve("成功")}}},reason => {}).then(value => {console.log(value);},reason => {console.log(reason);});

在浏览器中查看结果。

看，此时的对象被下一个then()当作promise处理了，并且打印出了成功。

同样的，只要返回的对象中有这个then()方法，那么它就会被当作是一个promise处理。

你可以在类中，在静态方法中都使用它，然后，返回的值就会被当作promise处理了。

接下来，我们来看第三点。

3. 每个then()会处理离自己最近的那个promise

这个概念其实更像一个工具，用来配对我们的promise和then，因为，在promise的使用中，并不都是像以上的例子中那样，有十分明显的链式结构，我们也会出现嵌套，

  let p1 = new Promise((resolve, reject) => {resolve("fulfilled");}).then(value => {return new Promise((resolve,reject)=>{resolve("我是第一个promise的then中新创建的promise")}).then(value => {console.log("成功"+value);},reason => {console.log(reason);})},reason => {}).then(value => {console.log(value);},reason => {console.log(reason);});

这就是一种明显的嵌套情况，是不是看起来很乱，这时候就用到了我们所说的“每个then()会处理离自己最近的那个promise” 。

在p1的下的第一个then()当中，我们创建了新的promise并返回，但是，在这个新的promise下面，我们定义了then()。此时这个新promise，是谁在处理，它下面的then(),还是p1的第二个then()?

我们先看浏览器的返回结果。

很明显，它被新promise下定义的then()直接处理了，并没有像通常的return一样，把它返回给了p1的第二个then()进行处理，所以，p1的第二个then()，可以直接删掉。

  let p1 = new Promise((resolve, reject) => {resolve("fulfilled");}).then(value => {return new Promise((resolve,reject)=>{resolve("我是第一个promise的then中新创建的promise")}).then(value => {console.log("成功"+value);},reason => {console.log(reason);})},reason => {})

以上就是本篇的全部内容了，是promise的入门部分，这是系列文章，剩下的内容会另开篇幅更新。介时会在这里放上链接

剩下的内容会尽快更新，每日更新或每两日更新，敬请期待~~

omise((resolve, reject) => {