简述Promise Promise.then Promise.all Promise.race

Promise

1.什么是Promise？

Promise　是一个对象。

2.promise的作用？

promise主要用于进行异步操作。

在Promise未出现前，我们通常是使用嵌套的回调函数来解决的。但是使用回调函数来解决异步问题，简单还好说，但是如果问题比较复杂，就会进入回调地狱。

3.Promise的三种状态？

 等待态（Pending）：初始状态

执行态（Fulfilled）：操作成功状态

拒绝态（Rejected）：操作失败状态

promise状态的变化：单向的从pending变为fulfilled从pending变为rejected。但是状态一旦改变就不会再变了。

4.使用Promise的优缺点？

优点：让回调函数变成了链式的写法，避免了回调地狱，程序的流程看的更清楚。

缺点：①无法取消Promise，一旦新建就立即执行，无法中途取消

②如果不设置回调函数。Promise内部抛出的错误，不会反应到外部。

5.Promise的创建

  var myPromise = new Promise((resolve, reject) => {

            // 进行异步处理

            // 调用resolve或者reject

        })

Promise有俩个参数resolve和reject；

resolve的作用是将Promise的状态从等待状态转变成成功状态，并把返回的数据传出来，reject的作用是将Promise的状态从等待状态转变成失败状态，将错误的信息返回。

Promise是对象，对象和函数的区别就是，对象的状态可以一直保持。

6.Promise的Api接口

1. Promise.resolve()

2. Promise.reject()

3. Promise.prototype.then()

4. Promise.prototype.catch()

5. Promise.all() // 所有的完成

6. Promise.race()

Promise.then()

1.promise.then()

对于已经实例化的Promise对象可以调用promise.then()方法，传递resolve和reject方法作为回调。

2.promise.then语法

promise.then(onFuilled,onRejected)。也可写成promise.then(onFuilled).catch(onRejected).

3.promise.then回调函数只能执行一次，且返Promise对象。

4.promise.then有两个参数：分别是promise的成功和失败情况的回调函数。

5.promise.then语法

var p=new Promise((resolve,reject)=>{
            resolve('成功');
            // reject(new Error("失败了"))
        });
        p.then(value=>{
            console.log(value);
        }).catch(reason=>{
            console.log(reason);
        })

注意：如果函数抛出的错误返回一个拒绝的Promise，则then将返回一个拒绝的Promise

Promise.all()

1.promise.all()方法用于将多个promise实例，包装成一个新的实例

var p=new Promise([p1,p2,p3]);

　promise.all（）中的实例不一定是数组，但是必须要有iterator接口（Array,Map,Set,String等）　

2.promise.all的使用

当实例的状态都变成Fulfilled状态，实例P才会变成Fulfilled'状态，将所有实例的返回值传递给p的回调函数。

但是当实例中有一个被rejected，p的状态就变成rejected状态，此时第一个被rejected的实例的返回值传递给p的回调函数。

通俗点就是都成功才会调用成功的回调函数。一旦有一个失败就调用失败的回调函数。

 var p1 = new Promise((resolve, reject) => {
            resolve('成功');
        })
 var p2 = new Promise((resolve, reject) => {
            resolve('success');
        })
 var p3 = Promise.reject('失败');
        
        var p = new Promise.all([p1, p2, p3]);
        var pp = new Promise.all([p1, p2,]);
        p.then(success => {
            console.log("success");
        }).catch(error => {
            console.log(error)//失败
        })
        pp.then(success => {
            console.log("success");//成功 success
        }).catch(error => {
            console.log(error)
        })

3.Promise.all()的应用场景

比如在支付的时候要判断支付的余额和商品的库存，当顾客的余额足够并且商品的库存有余是才可以支付成功，有一个情况不符合就无法完成支付。

Promise.race()

race：赛跑; 速度竞赛; 竞争; 角逐; 

也是将多个Promise实例包装成一个新的Promise实例

var p=new Promise([p1,p2,p3]);

但是与Promise.all（）不同的是，所有实例中只要有一个状态改变，p就跟着改变，率先改变的实例的返回值传递给p的回调函数；

   var p1 = new Promise((resolve, reject) => {
           setTimeout(()=>{
                resolve('success');
           },3000)
        })
        var p2 = new Promise((resolve, reject) => {
           setTimeout(()=>{
                reject('失败')
           },1000)
        })

        var p=new Promise.race([p1,p2]);
        p.then(success => {
            console.log("success");
        }).catch(error => {
            console.log(error);//reject 失败  p2的状态率先改变

        })

Promise.resolve （）

可以将不是Promise的对象转成Promise对象；生成的新的实例，实例状态为fulfilled，就会立即执行.

若promise.resolve()里面的参数本来就是Promise对象就会原封不动的返回。

var p=promise.resolve(hello);//p为promise对象

实例的参数还是回调函数的参数

var p = promise('hello');
        p.then(res => {
            console.log(res);//hello
        })

Promise.reject()

Promise.reject()方法也会返回一个新的Promise实例，实例的状态为rejected

var p = promise('出错了');
        p.then(res => {
            console.log(res);//出错了
        })

p2的状态率先改变