资讯专栏INFORMATION COLUMN

理解async/await

luodongseu / 872人阅读

摘要:所谓异步,就是调用在发出后,这个调用就直接返回了,调用者不会立即得到结果,但是不会阻塞,可以继续执行后续操作,而被调用者执行得到结果后通过状态事件来通知调用者使用回调函数来处理这个结果。另外状态的回调函数是可省略的。

首先明确一个问题,为什么 Node.js 需要异步编程?

JavaScript 是单线程的,在发出一个调用时,在没有得到结果之前,该调用就不返回,意思就是调用者主动等待调用结果,换句话说,就是必须等待上一个任务执行完才能执行下一个任务,这种执行模式叫:同步
Node.js 的主要应用场景是处理高并发(单位时间内极大的访问量)和 I/O 密集场景(ps: I/O 操作往往非常耗时,所以异步的关键在于解决 I/O 耗时问题),如果采用同步编程,问题就来了,服务器处理一个 I/O 请求需要大量的时间,后面的请求都将排队,造成浏览器端的卡顿。异步编程能解决这个问题。
所谓异步,就是调用在发出后,这个调用就直接返回了,调用者不会立即得到结果,但是不会阻塞,可以继续执行后续操作,而被调用者执行得到结果后通过状态、事件来通知调用者使用回调函数( callback )来处理这个结果。Node在处理耗时的 I/O 操作时,将其交给其他线程处理,自己继续处理其他访问请求,当 I/O 操作处理好后就会通过事件通知 Node 用回调做后续处理。
有个例子非常好:

你打电话问书店老板有没有《分布式系统》这本书,如果是同步通信机制,书店老板会说,你稍等,”我查一下",然后开始查啊查,等查好了(可能是5秒,也可能是一天)告诉你结果(返回结果)。而异步通信机制,书店老板直接告诉你我查一下啊,查好了打电话给你,然后直接挂电话了(不返回结果)。然后查好了,他会主动打电话给你。在这里老板通过“回电”这种方式来回调。

下面几种方式是异步解决方案的进化过程:

CallBacks

回调函数就是函数A作为参数传递给函数B,并且在未来某一个时间被调用。callback的异步模式最大的问题就是,理解困难加回调地狱(callback hell),看下面的代码的执行顺序:

A();
ajax("url1", function(){
    B();
    ajax("url2", function(){
        C();
    }
    D();
});
E();

其执行顺序为:A => E => B => D => C,这种执行顺序的确会让人头脑发昏,另外由于由于多个异步操作之间往往会耦合,只要中间一个操作需要修改,那么它的上层回调函数和下层回调函数都可能要修改,这就陷入了回调地狱。而 Promise 对象就很好的解决了异步操作之间的耦合问题,让我们可以用同步编程的方式去写异步操作。

Promise

Promise 对象是一个构造函数,用来生成promise实例。Promise 代表一个异步操作,有三种状态:pending,resolved(异步操作成功由 pending 变为 resolved ),rejected(异步操作失败由 pending 变为 rejected ),一旦变为后两种状态将不会再改变。Promise 对象作为构造函数接受一个函数作为参数,而这个函数又接受 resolve reject 两个函数做为参数,这两个函数是JS内置的,无需配置。resolve 函数在异步操作成功后调用,将pending状态变为resolved,并将它的参数传递给回调函数;reject 函数在异步操作失败时调用,将pending状态变为rejected,并将参数传递给回调函数。

Promise.prototype.then()

Promise构造函数的原型上有一个then方法,它接受两个函数作为参数,分别是 resolved 状态和 rejected 状态的回调函数,而这两个回调函数接受的参数分别是Promise实例中resolve函数和reject函数中的参数。 另外rejected状态的回调函数是可省略的。

下面是一个使用示例:

const instance = new Promise((resolve, reject) => {
    // 一些异步操作
    if(/*异步操作成功*/) {
      resolve(value);
    } else {
      reject(error);
    }
  }
})
instance.then(value => {
  // do something...
}, error => {
  // do something...
})

注意Promise实例在生成后会立即执行,而 then 方法只有在所有同步任务执行完后才会执行,看看下面的例子:

const promise = new Promise((resolve, reject) => {
  console.log("async task begins!");
  setTimeout(() => {
    resolve("done, pending -> resolved!");
  }, 1000);
})

promise.then(value => {
  console.log(value);
}) 

console.log("1.please wait");
console.log("2.please wait");
console.log("3.please wait");
// async task begins!
// 1.please wait
// 2.please wait
// 3.please wait
// done, pending -> resolved!

上面的实例可以看出,Promise实例生成后立即执行,所以首先输出 "async task begins!",随后定义了一个异步操作 setTimeout,1秒后执行,所以无需等待,向下执行,而then方法指定的回调函数要在所有同步任务执行完后才执行,所以先输出了3个"please wait",最后输出"done, pending -> resolved!"。(此处省略了then方法中的reject回调,一般不在then中做rejected状态的处理,而使用catch方法专门处理错误,相当于.then(null, reject))

链式调用 then 方法

then 方法会返回一个新的 Promise 实例,可以分两种情况来看:

指定返回值是新的 Promise 对象,如return new Promise(...),这种情况没啥好说的,由于返回的是 Promise,后面显然可以继续调用then方法。

返回值不是Promise, 如:return 1 这种情况还是会返回一个 Promise,并且这个Promise 立即执行回调 resolve(1)。所以仍然可以链式调用then方法。(注:如果没有指定return语句,相当于返回了undefined

使用 then 的链式写法,按顺序实现一系列的异步操作,这样就可以用同步编程的形式去实现异步操作,来看下面的例子,实现隔两秒打一次招呼:

function sayHi(name) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(name);
    }, 2000)
  })
}

sayHi("张三")
  .then(name => {
    console.log(`你好, ${name}`);
    return sayHi("李四");    // 最终 resolved 函数中的参数将作为值传递给下一个then
  })
  // name 是上一个then传递出来的参数
  .then(name => {                
    console.log(`你好, ${name}`);
    return sayHi("王二麻子");
  })
  .then(name => {
    console.log(`你好, ${name}`);
  })
// 你好, 张三
// 你好, 李四
// 你好, 王二麻子

可以看到使用链式then的写法,将异步操作变成了同步的形式,但是也带来了新的问题,就是异步操作变成了很长的then链,新的解决方法就是Generator,这里跨过它直接说它的语法糖:async/await

async/await

async

async/await实际上是Generator的语法糖。顾名思义,async关键字代表后面的函数中有异步操作,await表示等待一个异步方法执行完成。声明异步函数只需在普通函数前面加一个关键字async即可,如:

async function funcA() {}

async 函数返回一个Promise对象(如果指定的返回值不是Promise对象,也返回一个Promise,只不过立即 resolve ,处理方式同 then 方法),因此 async 函数通过 return 返回的值,会成为 then 方法中回调函数的参数:

async function funcA() {
  return "hello!";
}

funcA().then(value => {
  console.log(value);
})
// hello!

多带带一个 async 函数,其实与Promise执行的功能是一样的,来看看 await 都干了些啥。

await

顾名思义, await 就是异步等待,它等待的是一个Promise,因此 await 后面应该写一个Promise对象,如果不是Promise对象,那么会被转成一个立即 resolve 的Promise。 async 函数被调用后就立即执行,但是一旦遇到 await 就会先返回,等到异步操作执行完成,再接着执行函数体内后面的语句。总结一下就是:async函数调用不会造成代码的阻塞,但是await会引起async函数内部代码的阻塞。看看下面这个例子:

async function func() {
  console.log("async function is running!");
  const num1 = await 200;
  console.log(`num1 is ${num1}`);
  const num2 = await num1+ 100;
  console.log(`num2 is ${num2}`);
  const num3 = await num2 + 100;
  console.log(`num3 is ${num3}`);
}

func();
console.log("run me before await!");
// async function is running!
// run me before await!
// num1 is 200
// num2 is 300
// num3 is 400

可以看出调用 async func 函数后,它会立即执行,首先输出了"async function is running!",接着遇到了 await 异步等待,函数返回,先执行func()后面的同步任务,同步任务执行完后,接着await等待的位置继续往下执行。可以说,async函数完全可以看作多个异步操作,包装成的一个Promise 对象,而await命令就是内部then命令的语法糖。

值得注意的是, await 后面的 Promise 对象不总是返回 resolved 状态,只要一个 await 后面的Promise状态变为 rejected ,整个 async 函数都会中断执行,为了保存错误的位置和错误信息,我们需要用 try...catch 语句来封装多个 await 过程,如下:

async function func() {
  try {
    const num1 = await 200;
    console.log(`num1 is ${num1}`);
    const num2 = await Promise.reject("num2 is wrong!");
    console.log(`num2 is ${num2}`);
    const num3 = await num2 + 100;
    console.log(`num3 is ${num3}`);
  } catch (error) {
    console.log(error);
  }
}

func();
// num1 is 200
// 出错了
// num2 is wrong!

如上所示,在 num2 await 得到了一个状态为 rejected 的Promise对象,该错误会被传递到 catch 语句中,这样我们就可以定位错误发生的位置。

async/await比Promise强在哪儿?

接下来我们用async/await改写一下Promise章节中关于sayHi的一个例子,代码如下:

function sayHi(name) {
  return new Promise((resolved, rejected) => {
    setTimeout(() => {
      resolved(name);
    }, 2000)
  })
}

async function sayHi_async(name) {
  const sayHi_1 = await sayHi(name)
  console.log(`你好, ${sayHi_1}`)
  const sayHi_2 = await sayHi("李四")
  console.log(`你好, ${sayHi_2}`)
  const sayHi_3 = await sayHi("王二麻子")
  console.log(`你好, ${sayHi_3}`)
}

sayHi_async("张三")
// 你好, 张三
// 你好, 李四
// 你好, 王二麻子

与之前长长的then链和then方法里的回调函数相比,这样的写法看起来像是同步写法并且更加清爽,更加符合编程习惯。

参考文章

https://segmentfault.com/a/11...
https://segmentfault.com/a/11...
https://www.zhihu.com/questio...

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/95952.html

相关文章

  • 8张图帮你一步步看清 async/await 和 promise 的执行顺序

    摘要:第部分画图一步步看清宏任务微任务的执行过程我们以开篇的经典面试题为例,分析这个例子中的宏任务和微任务。注意这里只是把推入微任务队列,并没有执行。执行结束,才能继续执行后面的代码如图此时当前宏任务都执行完了,要处理微任务队列里的代码。 8张图让你一步步看清 async/await 和 promise 的执行顺序 为什么写这篇文章? 测试一下自己有没有必要看 需要具备的前置基础知识 主...

    weizx 评论0 收藏0
  • 理解 JavaScript 的 async/await

    摘要:因为函数返回一个对象,所以可以用于等待一个函数的返回值这也可以说是在等函数,但要清楚,它等的实际是一个返回值。帮我们干了啥作个简单的比较上面已经说明了会将其后的函数函数表达式或的返回值封装成一个对象,而会等待这个完成,并将其的结果返回出来。 随着 Node 7 的发布,越来越多的人开始研究据说是异步编程终级解决方案的 async/await。我第一次看到这组关键字并不是在 JavaSc...

    tracymac7 评论0 收藏0
  • promise async await 理解笔记

    摘要:在异步编程中,提供了对象的方式。例如等同于所以可以理解为生成一个实例。那么自然也可以去调用则是配合使用的。等于是等待一个返回值,等待的执行结果。但是函数不会造成阻塞,所以配合使用,则没有影响到外部。 在异步编程中,es6提供了promise对象的方式。简单的用法 var promise = new Promise((resolve,reject)=>{ if(){ ...

    NoraXie 评论0 收藏0
  • [译]带你理解 Async/await

    摘要:所以是在一秒后显示的。这个行为不会耗费资源,因为引擎可以同时处理其他任务执行其他脚本,处理事件等。每个回调首先被放入微任务队列然后在当前代码执行完成后被执行。,函数是异步的,但是会立即运行。否则,就返回结果,并赋值。 「async/await」是 promises 的另一种更便捷更流行的写法,同时它也更易于理解和使用。 Async functions 让我们以 async 这个关键字开...

    xiaochao 评论0 收藏0
  • 令人费解的 async/await 执行顺序

    摘要:问题的关键在于其执行过程中的微任务数量,下文中我们需要用上述代码中的方式对微任务的执行顺序进行标记,以辅助我们理解这其中的执行过程。 原文发布在掘金社区:https://juejin.im/post/5c3cc981f265da616a47e028 起源 2019年了,相信大家对 Promise 和 async/await 都不再陌生了。 前几日,我在社区读到了一篇关于 async/...

    WilsonLiu95 评论0 收藏0
  • 理解 async/await

    摘要:而函数的命令后面则可以是或者原始类型的值,,,但这时等同于同步操作返回值是。抛出的错误而会被方法回调函数接收到。 ES7 提出的async 函数,终于让 JavaScript 对于异步操作有了终极解决方案。No more callback hell。async 函数是 Generator 函数的语法糖。使用 关键字 async 来表示,在函数内部使用 await 来表示异步。想较于 G...

    kid143 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<