简介

因为javascript默认状况下是单线程的，这意味着代码不能创立新的线程来并行执行。然而对于最开始在浏览器中运行的javascript来说，单线程的同步执行环境显然无奈满足页面点击，鼠标挪动这些响应用户的性能。于是浏览器实现了一组API，能够让javascript以回调的形式来异步响应页面的申请事件。

更进一步，nodejs引入了非阻塞的 I/O ，从而将异步的概念扩大到了文件拜访、网络调用等。

明天，咱们将会深刻的探讨一下各种异步编程的优缺点和发展趋势。

同步异步和阻塞非阻塞

在探讨nodejs的异步编程之前，让咱们来探讨一个比拟容易混同的概念，那就是同步，异步，阻塞和非阻塞。

所谓阻塞和非阻塞是指过程或者线程在进行操作或者数据读写的时候，是否须要期待，在期待的过程中是否进行其余的操作。

如果须要期待，并且期待过程中线程或过程无奈进行其余操作，只能傻傻的期待，那么咱们就说这个操作是阻塞的。

反之，如果过程或者线程在进行操作或者数据读写的过程中，还能够进行其余的操作，那么咱们就说这个操作是非阻塞的。

同步和异步，是指拜访数据的形式，同步是指须要被动读取数据，这个读取过程可能是阻塞或者是非阻塞的。而异步是指并不需要被动去读取数据，是被动的告诉。

很显著，javascript中的回调是一个被动的告诉，咱们能够称之为异步调用。

javascript中的回调

javascript中的回调是异步编程的一个十分典型的例子：

document.getElementById('button').addEventListener('click', () => {  console.log('button clicked!');})

下面的代码中，咱们为button增加了一个click事件监听器，如果监听到了click事件，则会登程回调函数，输入相应的信息。

回调函数就是一个一般的函数，只不过它被作为参数传递给了addEventListener，并且只有事件触发的时候才会被调用。

上篇文章咱们讲到的setTimeout和setInterval实际上都是异步的回调函数。

回调函数的错误处理

在nodejs中怎么解决回调的错误信息呢？nodejs采纳了一个十分奇妙的方法，在nodejs中，任何回调函数中的第一个参数为谬误对象，咱们能够通过判断这个谬误对象的存在与否，来进行相应的错误处理。

fs.readFile('/文件.json', (err, data) => {  if (err !== null) {    //处理错误    console.log(err)    return  }  //没有谬误，则解决数据。  console.log(data)})

回调天堂

javascript的回调尽管十分的优良，它无效的解决了同步解决的问题。然而遗憾的是，如果咱们须要依赖回调函数的返回值来进行下一步的操作的时候，就会陷入这个回调天堂。

叫回调天堂有点夸大了，然而也是从一方面反映了回调函数所存在的问题。

fs.readFile('/a.json', (err, data) => {  if (err !== null) {    fs.readFile('/b.json',(err,data) =>{        //callback inside callback    })  }})

怎么解决呢？

别怕ES6引入了Promise，ES2017引入了Async/Await都能够解决这个问题。

ES6中的Promise

什么是Promise

Promise 是异步编程的一种解决方案，比传统的解决方案“回调函数和事件”更正当和更弱小。

所谓Promise，简略说就是一个容器，外面保留着某个将来才会完结的事件（通常是一个异步操作）的后果。

从语法上说，Promise 是一个对象，从它能够获取异步操作的音讯。

Promise的特点

Promise有两个特点：

  1. 对象的状态不受外界影响。

Promise对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已实现，又称 Fulfilled）和Rejected（已失败）。

只有异步操作的后果，能够决定以后是哪一种状态，任何其余操作都无奈扭转这个状态。

  1. 一旦状态扭转，就不会再变，任何时候都能够失去这个后果。

Promise对象的状态扭转，只有两种可能：从Pending变为Resolved和从Pending变为Rejected。

这与事件（Event）齐全不同，事件的特点是，如果你错过了它，再去监听，是得不到后果的。

Promise的长处

Promise将异步操作以同步操作的流程表达出来，防止了层层嵌套的回调函数。

Promise对象提供对立的接口，使得管制异步操作更加容易。

Promise的毛病

  1. 无奈勾销Promise，一旦新建它就会立刻执行，无奈中途勾销。
  2. 如果不设置回调函数，Promise外部抛出的谬误，不会反馈到内部。
  3. 当处于Pending状态时，无奈得悉目前停顿到哪一个阶段（刚刚开始还是行将实现）。

Promise的用法

Promise对象是一个构造函数，用来生成Promise实例：

var promise = new Promise(function(resolve, reject) { // ... some code if (/* 异步操作胜利 */){ resolve(value); } else { reject(error); } });

promise能够接then操作，then操作能够接两个function参数，第一个function的参数就是构建Promise的时候resolve的value，第二个function的参数就是构建Promise的reject的error。

promise.then(function(value) { // success }, function(error) { // failure });

咱们看一个具体的例子：

function timeout(ms){    return new Promise(((resolve, reject) => {        setTimeout(resolve,ms,'done');    }))}timeout(100).then(value => console.log(value));

Promise中调用了一个setTimeout办法，并会定时触发resolve办法，并传入参数done。

最初程序输入done。

Promise的执行程序

Promise一经创立就会立马执行。然而Promise.then中的办法，则会等到一个调用周期过后再次调用，咱们看上面的例子：

let promise = new Promise(((resolve, reject) => {    console.log('Step1');    resolve();}));promise.then(() => {    console.log('Step3');});console.log('Step2');输入：Step1Step2Step3

async和await

Promise当然很好，咱们将回调天堂转换成了链式调用。咱们用then来将多个Promise连接起来，前一个promise resolve的后果是下一个promise中then的参数。

链式调用有什么毛病呢？

比方咱们从一个promise中，resolve了一个值，咱们须要依据这个值来进行一些业务逻辑的解决。

如果这个业务逻辑很长，咱们就须要在下一个then中写很长的业务逻辑代码。这样让咱们的代码看起来十分的冗余。

那么有没有什么方法能够间接返回promise中resolve的后果呢？

答案就是await。

当promise后面加上await的时候，调用的代码就会进行直到 promise 被解决或被回绝。

留神await肯定要放在async函数中，咱们来看一个async和await的例子：

const logAsync = () => {  return new Promise(resolve => {    setTimeout(() => resolve('小马哥'), 5000)  })}

下面咱们定义了一个logAsync函数，该函数返回一个Promise，因为该Promise外部应用了setTimeout来resolve，所以咱们能够将其看成是异步的。

要是应用await失去resolve的值，咱们须要将其放在一个async的函数中：

const doSomething = async () => {  const resolveValue = await logAsync();  console.log(resolveValue);}

async的执行程序

await实际上是去期待promise的resolve后果咱们把下面的例子联合起来：

const logAsync = () => {    return new Promise(resolve => {        setTimeout(() => resolve('小马哥'), 1000)    })}const doSomething = async () => {    const resolveValue = await logAsync();    console.log(resolveValue);}console.log('before')doSomething();console.log('after')

下面的例子输入：

beforeafter小马哥

能够看到，aysnc是异步执行的，并且它的程序是在以后这个周期之后。

async的特点

async会让所有前面接的函数都变成Promise，即便前面的函数没有显示的返回Promise。

const asyncReturn = async () => {    return 'async return'}asyncReturn().then(console.log)

因为只有Promise能力在前面接then，咱们能够看出async将一个一般的函数封装成了一个Promise：

const asyncReturn = async () => {    return Promise.resolve('async return')}asyncReturn().then(console.log)

总结

promise防止了回调天堂，它将callback inside callback改写成了then的链式调用模式。

然而链式调用并不不便浏览和调试。于是呈现了async和await。

async和await将链式调用改成了相似程序程序执行的语法，从而更加不便了解和调试。

咱们来看一个比照，先看下应用Promise的状况：

const getUserInfo = () => {  return fetch('/users.json') // 获取用户列表    .then(response => response.json()) // 解析 JSON    .then(users => users[0]) // 抉择第一个用户    .then(user => fetch(`/users/${user.name}`)) // 获取用户数据    .then(userResponse => userResponse.json()) // 解析 JSON}getUserInfo()

将其改写成async和await：

const getUserInfo = async () => {  const response = await fetch('/users.json') // 获取用户列表  const users = await response.json() // 解析 JSON  const user = users[0] // 抉择第一个用户  const userResponse = await fetch(`/users/${user.name}`) // 获取用户数据  const userData = await userResponse.json() // 解析 JSON  return userData}getUserInfo()

能够看到业务逻辑变得更加清晰。同时，咱们获取到了很多两头值，这样也不便咱们进行调试。

本文作者：flydean程序那些事

本文链接：http://www.flydean.com/nodejs-async/

本文起源：flydean的博客

欢送关注我的公众号:「程序那些事」最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！