关于Promise

Promise是一部编程的一种解决方案，

简单说就是一个容器，里面保存着么某个未来才会结束的事件（通常是一个异步操作）的结果

是为了简化异步对象，解决地狱回调情况

Promise：有两个回调函数：resolve：将对象的状态从未完成变成成功

　　　　　　　　　　　：reject：将对象的状态从未完成变成失败

 

下面的代码是展示一个Promise的简单异步调用：

            var p = new Promise(function(resolve,reject){
                //做一些异步操作
                setTimeout(function(){
                    console.log("执行完毕！");
                    resolve("成功！");
                },2000);
            });
            //调用
            p.then(function(add){
                console.log(add);
            });

 

下面是封装一个简单的Promise：

function pro(){
                let p = new Promise(resolve,reject){
                    setTimeout(function(){
                        console.log("执行完毕！");
                        resolve("成功！");
                    },2000);
                } 
                return p;
            }
            pro().then(function(data){
                console.log(data);
            })

then：可以接受两个回掉函数作为参数，（成功回调）和（失败回调），其中失败回调可选，这两个参数都接受Promise传出的值作为参数

resolve的用法：把Promise的状态置为rejected，这样就能在then中捕获到，然后执行 “失败” 情况的回调

            function getName(){
                var p = new Promise(function(resolve,reject){
                    setTimeout(function(){
                        var num = Math.ceil(Math.random()*10);
                        if(num>5){
                            resolve(num);
                        }else{
                            reject("数字大于5了！");
                        }
                    },2000);
                })
                return p;
            };
            getName().then(function(data){
                console.log(resolve);
                console.log(data);
            },function(reject,data){
                console.log(reject);
                console.log(data);
            });

 

Promise.catch()方法是捕获错误的，用于指定发生错误时的回调函数

下面的一段代码：

primose.then(val=>{
                console.log("成功",val);
            }).catch(err=>{
                console.log("失败",err);
            })

Promise。all()    吧Promise打包，扔到一个数组里面。打包完还是一个Promise对象，必须确保所有的Promise对象，都是resolve对象，都是成功的状态

即：将多个Promise实例，包装才能一个新的Promise实例

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

Promise.all()方法接受一个数组作为参数，p1，,p2，p3都是Promise对象的实例，如果不是就会 先调用Promise的resolve方法，将参数转换化Promise实例，在进一步处理

（改方法参数可以不是数组，但是必须具有iterator，且返回的每个成员都是Promise实例）

Promise.race() 同样是将多个Promise实例，包装成一个新的Promise实例

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

上面的代码中p1，p2，p3，三个中有一个实例率先改变状态，P的状态就会跟着改变

跟上面你的Promise.all()一样，如果不是Promise实例，就会调用Promise的resolve

            let fun1=()=>{
                return new Promise((resolve,reject)=>{
                    console.log("执行了方法1");
                });
            }
            let fun2=()=>{
                return new Promise((resolve,reject)=>{
                    console.log("执行了方法2");
                })
            }
            let fun3=()=>{
                return new Promise((resolve,reject)=>{
                    console.log("执行了方法3");
                })
            }
            const arr = [fun1(),fun2(),fun3()];
            Promise.all(arr).then(()=>{
                console.log("全部执行完毕！");
                //console.log(data)["执行了方法1"，"执行了方法2"，"执行了方法3"，]
            });//如果三个方法里面的任何一个改变状态为reject,则报错

Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

var promise1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, 'one');
});

var promise2 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, 'two');
});

Promise.race([promise1, promise2]).then(function(value) {
  console.log(value);
  // Both resolve, but promise2 is faster
});
// expected output: "two"