关于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"