這樣理解 promise

promise是什麼

官網解釋 promise 表示一個異步操做的最終結果。

翻譯 ==能夠將promise理解爲一個狀態機==，它存在三種不一樣的狀態，並在某一時刻只能有一種狀態

• pending 表示還在執行
• resolved 執行成功
• rejected 執行失敗

一個promise是對一個異步操做的封裝，異步操做有等待完成、成功和失敗三種可能的結果，對應了promise的三種狀態。

promise的狀態只能有pending轉換位resolved或者pending轉換爲rejected，一旦狀態轉化完成就沒法再改變。

假設咱們用promise封了一個異步操做，那麼當它被建立的時候就處於pending狀態，當異步操做成功完成時，
咱們將狀態轉換爲resolved，若是執行中出現錯誤，將狀態轉換爲rejected。

var promise=new Promise(function(resolve,reject){
  // code
  if(){
    /*異步操做成功 */
    resolve(value)
  }else{
    reject(error)
  }
})

使用then方法獲取結果

var fs=require('fs')
function readFile_promise(path){
  return new Promise(function(resolve,reject){
    fs.readFile(path, 'utf-8',function(err,data){
      if(data){
        resolve(data)
      }else{
        reject(err)
      }
    })
  })
}

var result=readFile_promise('./1.txt')
result.then(function(value){
  //success
  console.log('success', value)
},function(error){
  //failure
  console.log('failure',error)
})
// 將一個異步函數封裝成promise，只要在回調函數中針對不一樣的返回結果調用resolve或者reject方法。

// resolve函數會在異步操做成功完成時被調用，並將異步操做的返回值做爲參數傳遞到外部。
// reject是在異步操做出現異常時被調用，會將錯誤信息做爲參數傳遞出去。

then方法的返回值

then方法老是返回一個新的promise對象，屢次調用then方法，默認返回一個一個空的promise對象
使用return來來返回。

var promise=readFile_promise('./foo.txt')
promise.then(function(value){
  //success
  console.log('success', value) // foo
  return readFile_promise('./bar.txt')
},function(error){
  //failure
  console.log('failure',error)
}).then(function(value){
  console.log('then', value) // bar
})

promise的執行

• 雖然咱們是經過then方法來獲取promise的結果，可是promise是當then方法調用以後才執行嗎？

var promise=new Promise((resolve, reject)=>{
  console.log('begin')
  resolve()
})

setTimeout(()=>{
  promise.then(()=>{
    console.log('end')
  })
},5000)
// 開始begin 5s後end
// 運行順序是，當promise從被建立的那一刻起就開始執行了，then方法只是提供了訪問promise狀態的接口，與promise的執行無關。

promise 經常使用的api

• resolved
• rejected
• all
• race 方法接收一個promise數組做爲參數並返回一個新的promise，數組中的promise會同時開始執行，race返回的promise的狀態有數組中率先執行完畢的promise的狀態決定
• catch 執行出錯可使用throw關鍵字拋出錯誤，並使用catch方法進行捕獲

// 若是有多個promise須要執行，可使用promise.all()
// 方法統一聲明，改方法能夠將多個promise對象包裝成一個promise
// 該方法接收一個數組做爲參數，數據的元素若是不是promise對象，則回先調用resolve方法轉換。
//  若是中間有一個promise狀態是reject，那麼轉換後的promise也會變成reject，而且將錯誤信息傳給catch方法
var promises=['foo.txt','bar.txt','baz.txt']
promises.map(function(path){
  // console.log(path)
  return readFile_promise(path)
})

Promise.all(promises).then(function(results){
  console.log(results) // [ 'foo.txt', 'bar.txt', 'baz.txt' ] 順序排列的
}).catch(function(err){
  // 
})

使用promise組織異步代碼

// 例子； 有三個文本文件須要順序讀取
var lists=['foo.txt','bar.txt','baz.txt']
var count=0;
readFile_promise('foo.txt').then(readCB).then(readCB).then(readCB);

function readCB(data){
  console.log(data) // foo bar baz
  if(++count>2){
    return
  }
  return readFile_promise(lists[count])
}

async/await

await關鍵字後面每每是一個promise，若是不是就隱式調用promise.resolve來轉換成一個promise。
await 等待後面的promise執行完成再進行下一步操做。

var asyncReadFile=async function(){
  var result1=await readFile_promise('./foo.txt')
  console.log(result1.toString()) // foo
}
asyncReadFile()

async返回值

async函數老是會返回一個promise對象，若是return關鍵字後面不是一個promise，那麼默認
調用promise。resolve方法進行轉換。

async function asyncFunc(){
  return 'hello Node'
}
asyncFunc().then(function(data){
  console.log(data) // hello Node
})

async函數的執行過程

1. 在async函數開始執行的時候回自動生成一個promise對象。
2. 當方法體開始執行後，若是遇到return關鍵字或者throw關鍵字，執行會馬上退出，

若是遇到await關鍵字則回暫停執行 await後面的異步操做結束後會恢復執行

1. 執行完畢，返回一個promise

async function asyncFunc(){
  console.log('begin')
  return 'hello Node'
}
asyncFunc().then(function(data){
  console.log(data) // hello Node
  console.log('end')
})
// begin 
// hello 
// end

await

await 操做符的結果是由其後面promise對象的操做結果來決定的，若是後面promise對象變爲resolved,
await操做符發返回的值就是resolve的值；若是promise對象的狀態變成rejected，那麼await也會拋出reject的值。

async function readFile(){
  var result=await readFile_promise('./foo.txt')
  console.log(result) // foo
}
readFile()

// 等價於
readFile_promise('foo.txt').then(function(data){
  console.log(data) // foo
})

await於並行

await會等待後面的promise完成後再採起下一步動做，這意味着當多個await操做時，程序會便成徹底的
串行操做。

當異步操做之間不存在依賴關係時，可使用promise.all來實現並行。

async function readFile(){
  const [result1, result2]=await Promise.all([
    readFile_promise('./foo.txt'),
    readFile_promise('./bar.txt')
  ])
  console.log(result1, result2) // foo bar
}
readFile()

// 等價於
function readFile(){
  return Promise.all([
    readFile_promise('./foo.txt'),
    readFile_promise('./baz.txt')
  ]).then((result)=>{
    console.log(result) // [ 'foo', 'baz' ]
  })
}
readFile()

await 總結

await關鍵字使用的一些關鍵點

• await關鍵字必須位於async函數內部
• await關鍵字後面須要是一個promise對象（不是的話就調用了resolve轉換的）
• await關鍵字的返回結果就是在其後面promise執行的結果，多是resolved或者rejected的值
• 不能在普通箭頭函數中使用await關鍵字，須要在箭頭函數前面加上async關鍵字。
• await用來串行地執行異步操做，想實現並行使用promise.all

async函數 的缺點

• 假設咱們有不少層的方法調用，最底層的異步操做被封裝成了async方法，那麼該函數的全部上層方法可能都要變成async方法。