边城

Node.js 异步最佳实践 & 避免回调地狱 | @RisingStack

边城 · 2017-01-31翻译 · 4461阅读 原文链接

本文涵盖了处理 Node.js 异步操作的一些工具和技术:async.jsPromisegenerator异步函数

阅读这篇文章之后你会知道如何避免臭名昭著的回调地狱!


> Node.js at Scale 是系列文章,专注于使用大型 Node.js 设施的公司和高级 Node 开发者。章节包括:


Node.js 中的异步编程

之前我们学习了关于JavaScript 中的异步编程的知识,也了解了Node.js 事件循环如何运作。

如果你还没有读这些文章,我强烈建议你去读一读!

Node.js 异步编程的问题

Node.js 本身是单线程的,但有些任务以并行的方式进行 —— 这受益于它的异步特性。

但并行的实际意义是什么?

我们在单线程VM中进行开发,但本质上来说我们不会因为I/O而阻塞,它会并行处理,这受益于 Node.js 的事件驱动 API。

来看一些基本的模块,学习如何通过 Node.js 内建的解决方案和一些第三方库来写一些高效利用资源、非阻塞的代码。

经典方法 - 回调

看看这些简单的异步操作。它们没做什么特别的事情,只是设置了一个定时器并在定时结束的时候调用一个函数。

function fastFunction (done) {  
  setTimeout(function () {
    done()
  }, 100)
}

function slowFunction (done) {  
  setTimeout(function () {
    done()
  }, 300)
}

看起来容易,是吗?

高阶函数可以通过一个基本的模式,嵌入回调,顺序或并行地执行。——但使用这个方法会导致难以控制的回调地狱。

function runSequentially (callback) {  
  fastFunction((err, data) => {
    if (err) return callback(err)
    console.log(data)   // 结果 a

    slowFunction((err, data) => {
      if (err) return callback(err)
      console.log(data) // 结果 b

      // 这里继续执行其它任务
    })
  })
}

"永远不要使用嵌入回调的方式来处理异步 #nodejs 操作!" —— @RisingStack

推特

通过控制流管理避免回调地狱

> 要成为一个高效的 Node.js 开发者,你必须避免不断增加的缩进级别,书写简洁且易读的代码,以及处理复杂的流程。

让我向你介绍一些库,它们能组织代码,使之简洁,而且易于维护!

#1: Async 模块

> Async 是一个工具,它向JavaScript异步编程提供了直接而强大的功能。

Async 包含了错误作为回调第一个参数的异步流程控制的常见模式。

来看看前面的例子用 Async 来实现是什么样!

async.waterfall([fastFunction, slowFunction], () => {  
  console.log('done')
})

> 这是什么魔法?

实事上,并没有魔法。 你自己也可以很容易用 Async 实现并行任务并等待它们完成。

来看看 Async 在背后做了什么!

// 来自 https://github.com/caolan/async/blob/master/lib/waterfall.js
function(tasks, callback) {  
    callback = once(callback || noop);
    if (!isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));
    if (!tasks.length) return callback();
    var taskIndex = 0;

    function nextTask(args) {
        if (taskIndex === tasks.length) {
            return callback.apply(null, [null].concat(args));
        }

        var taskCallback = onlyOnce(rest(function(err, args) {
            if (err) {
                return callback.apply(null, [err].concat(args));
            }
            nextTask(args);
        }));

        args.push(taskCallback);

        var task = tasks[taskIndex++];
        task.apply(null, args);
    }

    nextTask([]);
}

本质上来说,函数中注入了新的回调,所以 Async 知道函数什么时候完成。

#2: 使用 co - 基于 generator 的 Node.js 流程控制

如果你不喜欢总是回调,co 会是个不错的选择。

> co 是一个基于 generator 的流程控制工作,可用于 Node.js 和浏览器。它可以通过 Promise 让你的非阻塞代码以一种漂亮的方式呈现。

co 是个非常不错的选择,它利用 generator 函数 来使用 Promise,不再需要自己实现迭代器。

const fastPromise = new Promise((resolve, reject) => {  
  fastFunction(resolve)
})

const slowPromise = new Promise((resolve, reject) => {  
  slowFunction(resolve)
})

co(function * () {  
  yield fastPromise
  yield slowPromise
}).then(() => {
  console.log('done')
})

现在这个阶段,我建议使用 co。目前大家都在期待的 Node.js async/await 功能只能在非稳定版本的 Node.js v7.x 中使用。不过如果你已经在使用 Promise,要从 co 切换到 async 函数是件非常容易的事情。

> 这是 Promise 上的语法糖,和 generator 一起使用可以消除回调问题,甚至还能帮助建立漂亮的流程控制结构。它使得写异步代码就跟写同步代码一样,不是吗?

稳定的 Node.js 分支会在不久以后加入 async/await 功能。那时候 co 就可以退出历史舞台了。

流程控制实践

我们已经学习了一些工具和技巧来处理异步。是时候进行一些基本的控制流程来改善代码了,它会让代码简洁而且高效。

现在跟随示例,写一个 Web 应用的路由处理器 handler。这个处理器中需要进行三个步骤:validateParamsdbQueryserviceCall

如果你在不使用任何工具的情况下写这段代码,最终写出来的东西肯定不怎么好看:

// validateParams、dbQuery、serviceCall 都是高阶函数
// 不要
function handler (done) {  
  validateParams((err) => {
    if (err) return done(err)
    dbQuery((err, dbResults) => {
      if (err) return done(err)
      serviceCall((err, serviceResults) => {
        done(err, { dbResults, serviceResults })
      })
    })
  })
}

我们之前了解过,这种情况可以使用 Async 库来重构代码:

// validateParams、dbQuery、serviceCall都是高阶函数
function handler (done) {  
  async.waterfall([validateParams, dbQuery, serviceCall], done)
}

进一步用 Promise 重构:

// validateParams、dbQuery、serviceCall 都是 Thunk 函数
function handler () {  
  return validateParams()
    .then(dbQuery)
    .then(serviceCall)
    .then((result) => {
      console.log(result)
      return result
    })
}

> [译者注] 关于 thunk 的含义,请参考阮一峰老师的 Thunk函数的含义和用法

也可以用 co 加强的 generator 和 Promise 来实现:

// validateParams、dbQuery、serviceCall 都是 Thunk 函数
const handler = co.wrap(function * () {  
  yield validateParams()
  const dbResults = yield dbQuery()
  const serviceResults = yield serviceCall()
  return { dbResults, serviceResults }
})

这段代码感觉很像是“同步”代码,但它不是同步的,它会在一个异步工作完成之后再继续进行。

现在来看看如何用 async/await 来改写这段代码。

// validateParams、dbQuery、serviceCall 都是 Thunk 函数
async function handler () {  
  await validateParams()
  const dbResults = await dbQuery()
  const serviceResults = await serviceCall()
  return { dbResults, serviceResults }
})

Node.js 中异步的规则

非常幸运,Node.js 中写线程案例的代码并不麻烦,你只需要遵循一些规则就可以了

  • 作为一个经验法则,尽可能使用异步 API 而不是同步 API。因为非阻塞的方式比同步的方式性能更好。

  • 总是选用最合适的流程控制,或者组合的流程控制,以减少等待 I/O 完成的时间。

你可以在这个 代码库 中找到这篇文章的所有代码。

如果你有针对这篇文章的问题或建议,请通过评论告诉我们。

我们会在 Node.js at Scale 系列的一个部分继续了解 示例讲解事件来源

相关文章