Promise/async、await帮我们处置惩罚了什么

它给我们供应了一种新的异步编程处置惩罚计划，同时避免了搅扰已久的回调地狱

// 异步的处置惩罚可能会发生如许的回调地狱（第二个异步操纵和第一个异步的效果有关联）
let Ajax = function(data, success, error){
  $.ajax({
      data: data,
      success: function(res){
        success(res)
      },
      error: function(err){
        error(err)
      }
  })
}
Ajax(data,function(res){
  Ajax(data,function(res){
    // 继承轮回回调
  },function(err){})
},function(err){})
// 看看promise的处置惩罚方式
let promise = function (data) {
  return new Promise((resolve,reject) => {
      $.ajax({
          data: data,
          success: function(res){
              resolve(res)
          },
          error: function(err){
              reject(err)
          }
      })
  })
}
let data = {} // ajax要求参数
promise(data).then((res) => {return promise(res)}).catch(err => console.log(err)).then(res => console.log(res))
// async 、await的处置惩罚方式使得异步操纵更轻易
(async function(){
let res = await promise(data)
let resp = await promise(res)
console.log(resp)
})()

Promise的要领总结

Promise.prototype.then()

Promise.prototype.catch()

Promise.prototype.finally()

Promise.all()

# 当存在多个没有相关性的异步操纵时想一次性取得一切效果，能够运用promise.all()
Promise.all([p1,p2,p3])
只有当一切异步操纵状况变成resolve的时刻
返回一切值得数组
当有一个返回reject的时刻
返回值为第一个reject的值

Promise.race()

# 当存在多个没有相关性的异步操纵时,想要取得返回速率最快的异步操纵采纳
Promise.race([p1,p2,p3])
该要领返回第一个有返回值的异步操纵的返回值（resolve或许reject）
Promise.race([new Promise((resolve, reject) => {
  console.log('init p1')
  setTimeout(()=>{
    console.log('init p1 +')
    resolve('p1')
  },2000)
}),new Promise((resolve, reject) => {
  console.log('init p2')
  setTimeout(()=>{
    console.log('init p2 +')
    resolve('p2')
  },1000)
})]).then(res=>{console.log(res)})
运用场景：设定一个要求的超时时候
Promise.race([new Promise((resolve,reject)=>{
    setTimeout(()=>{
        resolve('1')
    },2000)
}),new Promise((resolve,reject)=>{
    setTimeout(()=>{
        reject(new Error('time out'))
    },1000)
})]).then((res=>console.log(res)))

Promise.resolve()

Promise.resolve('111').then(res=>console.log(res))

Promise.reject()

Promise.reject('err').catch(res=>console.log(res))

Promise.try()[现在只是一个提案]

# 【运用机遇】关于一个要领假如不知道是同步异步要领，然则想要用then来做后续操纵，同时愿望同步要领同步实行，异步要领异步实行。
# 等价计划
(async () => f())()
.then(res=>console.log(res))
.catch(err=>console.log(err))

async须要注重什么

毛病的捕捉

const f = () => console.log('now')
(async () => f())()
# async 会吃掉f()的毛病,能够经由过程promise.catch()来捕捉
(async () => f())()
.then(res=>console.log(res))
.catch(err=>console.log(err))

参考

Promise
async/await