Promise

是異步編程的一種解決方案，比傳統的解決方案（回調函數和事宜）更合理和更壯大。它由社區最早
出和完成，ES6 將其寫進了言語規範，一致了用法，原生供應了Promise對象。

所謂Promise，簡樸說就是一個容器，內里保存着某個將來才會完畢的事宜（通常是一個異步操縱）的效果。從語法上說，Promise 是一個對象，從它可以獵取異步操縱的音訊。Promise 供應一致的 API，種種異步操縱都可以用一樣的要領舉行處置懲罰。
有了Promise對象，就可以將異步操縱以同步操縱的流程表達出來，避免了層層嵌套的回調函數。另外，Promise對象供應一致的接口，使得掌握異步操縱越發輕易。

異步的解決方案：

• 1）傳統ajax

      是一種異步的JavaScript的要求，可以在不影響當前歷程的狀況下和背景舉行交互.
             1.提議要求
                 要求的返回時候難以確定，影響要素比較多，比方收集耽誤
             2.監聽（勝利，失利）
                 經由過程推斷狀況碼來決議實行誰人回調函數
                 200 ok
                 404 not found
                 500 背景代碼非常
                 403 無權接見
                 304 文檔內容沒有發作轉變
             3.挪用回調函數
                 完成要求后的處置懲罰
  
  
  
           $.getJSON('http://120.78.164.247:8080/grade',function(data){
             alert(data)
             });
             alert('end');
             //先實行end 在彈出data
  

湧現的題目：在回調函數中嵌套假如比較多，就很輕易出題目

• 2）promise

     許諾
     存在三種狀況：
         1.未知狀況，
         2.勝利狀況，resolve() 未知狀況---》勝利狀況
         3.失利狀況,reject()    未知狀況---》失利狀況
     ajax中運用最多
     
     
     let promise = new Promise((resolve,reject)=>{
     $.ajaxSetup({
         error:function(){reject()};    //失利
        });
         $.get('',function(data){
         resolve(data);    //勝利
        });
     promise.then(()={}).catch(()=>{});
  

在我的明白中promise是對ajax的一種封裝,上述代碼中，運用的是用JQuery封裝的ajax代碼分紅了兩部分。

對異步操縱Ajax的封裝

• 1.先來看看我們本身封裝一個Ajax

    let fetch = (method,url,successHandler,errorHandler)=>{
        let xhr = new XMLHttpRequest();
        xhr.open(method,url);
        xhr.responseType = 'json';
        xhr.setRequestHeader('Accept','application/json');//設置頭部信息
        
        xhr.onreadystatechange = function(){
            if(this.readyState == 4){
                if(this.status == 200){
                    successHandler(this.response)
                }else{
                    errorHandler(this.response);
                };
            }
        };
        xhr.send();
    
    }

須要注重的是因為原生代碼中須要http協定，所以這個代碼在node中是沒法運用的，

• 2.下面來看看運用promise來封裝

  簡樸的思緒：

     let promise = new Promise((resolve,reject)=>{
     
         setTimeout(function(){//模仿異步要求
             if (Math.round(Math.random()*10)>5) {
                         resolve('success');//勝利
                     }else{
                         reject('erro');//失利
                     }
     
         },3000);
     
     });
     
     promise.then((data)=>{
         console.log(data);
     }).catch((erro)=>{
         console.log(erro);
     });
  

  我們來看看promise怎樣封裝Ajax

     let fetch = (method,url)=>{
         return new Promise((resolve,reject)=>{
             let xhr = new XMLHttpRequest();//聲明一個要求
             xhr.open(method,url);
             xhr.responseType = 'json';
             xhr.setRequestHeader('Accept','application/json');
             xhr.onreadystatechange = function(){
                 if(this.readyState == 4){//推斷狀況
                 if(this.status == 200){
                     resolve(this.response)
                 }else{
                     reject(this.response);
                 };
             };
             };
                 xhr.send();//發送要求
         });
     };
     fetch('get','http://120.78.164.247:8080/grade/findAll').then(({code,msg,extend})=>{
         console.log(code);
         console.log(msg);
         console.log(extend);
     }).catch(()=>{});//挪用本身封裝的fetch
     
     

Promise經常使用要領

接着，我們來看看Promise中的一些基礎用法

• 1.Promise.prototype.then()

   .then(function(){//success},functions(){//error});
  

then要領是定義在原型對象Promise.prototype上的，也就是說，Promise 實例具有then要領。它的作用是為 Promise 實例增加狀況轉變時的回調函數。then要領的第一個參數是Resolved狀況的回調函數，第二個參數（可選）是Rejected狀況的回調函數。then要領返回的是一個新的Promise實例（注重，不是本來誰人Promise實例）。因而可以採納鏈式寫法，即then要領背面再挪用另一個then要領。假如運用兩個then要領，第一個回調函數完成今後，會將返回效果作為參數，傳入第二個回調函數。

getJSON("/post/1.json").then( 
    post => getJSON(post.commentURL)
 ).then( 
    comments => console.log("Resolved: ", comments), 
    err => console.log("Rejected: ", err) 
); 

上面代碼中，第一個then要領指定的回調函數，返回的是另一個Promise對象。這時候，第二個then要領指定的回調函數，就會守候這個新的Promise對象狀況發作變化。假如變成resolved，就挪用funcA，假如狀況變成rejected，就挪用funcB。

• 2.Promise.prototype.catch()

Promise.prototype.catch要領是.then(null, rejection)的別號，用於指定發作毛病時的回調函數，一般來說，不要在then要領內里定義Reject狀況的回調函數（即then的第二個參數），老是運用catch要領。

var promise = new Promise(function(resolve, reject) { 
    reject(new Error('test')); 
});
 promise.catch(function(error) { 
    console.log(error);
 });

Promise 對象的毛病具有“冒泡”性子，會一向向後通報，直到被捕捉為止。也就是說，毛病老是會被下一個catch語句捕捉。

• 3.Promise.all()

Promise.all要領用於將多個 Promise 實例，包裝成一個新的 Promise 實例。

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

上面代碼中，Promise.all要領接收一個數組作為參數，p1、p2、p3都是 Promise 實例，p的狀況由p1、p2、p3決議，分紅兩種狀況。
只需p1、p2、p3的狀況都變成fulfilled，p的狀況才會變成fulfilled，此時p1、p2、p3的返回值構成一個數組，通報給p的回調函數。
只需p1、p2、p3當中有一個被rejected，p的狀況就變成rejected，此時第一個被reject的實例的返回值，會通報給p的回調函數。

• 4.Promise.race()

Promise.race要領一樣是將多個Promise實例，包裝成一個新的Promise實例。下面代碼中，只需p1、p2、p3當中有一個實例領先轉變狀況，p的狀況就隨着轉變。誰人領先轉變的 Promise 實例的返回值，就通報給p的回調函數。

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

上面代碼中，Promise.all要領接收一個數組作為參數，p1、p2、p3都是 Promise 實例，p的狀況由p1、p2、p3決議，分紅兩種狀況。
只需p1、p2、p3的狀況都變成fulfilled，p的狀況才會變成fulfilled，此時p1、p2、p3的返回值構成一個數組，通報給p的回調函數。
只需p1、p2、p3當中有一個被rejected，p的狀況就變成rejected，此時第一個被reject的實例的返回值，會通報給p的回調函數。

• 5.Promise.resolve()

要領將現有對象轉為Promise對象，比方：

var jsPromise = Promise.resolve($.ajax('/whatever.json')); 

依據參數的差別，要領的返回值也會發作變化：

1.參數是一個Promise實例
Promise.resolve將不做任何修正、一成不變地返回這個實例。
2.參數是一個thenable對象
thenable對象指的是具有then要領的對象，Promise.resolve要領會將這個對象轉為Promise對象，然後就馬上實行thenable對象的then要領。
3.參數不是具有then要領的對象，或基礎就不是對象
假如參數是一個原始值，或者是一個不具有then要領的對象，則Promise.resolve要領返回一個新的Promise對象，狀況為Resolved。
4.不帶有任何參數
直接返回一個Resolved狀況的Promise對象。須要注重的是，馬上resolve的Promise對象，是在本輪“事宜輪迴”（event loop）的完畢時，而不是鄙人一輪“事宜輪迴”的開始時。

• 6.Promise. reject()

Promise.reject(reason)要領也會返回一個新的 Promise 實例，該實例的狀況為rejected 。

var p = Promise.reject('出錯了'); 
// 等同於 
var p = new Promise((resolve, reject) => reject('出錯了')) ;

• 7.finally()

finally要領用於指定不論Promise對象末了狀況怎樣，都邑實行的操縱。它接收一個一般的回調函數作為參數，該函數不論怎樣都必須實行。
下面是一個例子，服務器運用Promise處置懲罰要求，然後運用finally要領關掉服務器

server.listen(0) .then(function () {
     // run test
 }) .finally(server.stop);    //關掉服務器

運用總結

Promise對象的運用大抵分為以下幾個步驟：

 1. 構建許諾對象
    let promise = new Promise((resolve,reject)=>{
      // resolve()    未知->勝利
      // reject()     未知->失利
    });
 2. 實行
    promise.then(()=>{
      //勝利后的回調
    }).catch(()=>{
      //失利后的回調
    });

 3. 企業級運用