關於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"