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

本文转载自：众成翻译
译者：边城
链接：http://www.zcfy.cc/article/2442
原文：https://blog.risingstack.com/node-js-async-best-practices-avoiding-callback-hell-node-js-at-scale/

本文涵盖了处理 Node.js 异步操作的一些工具和技术：async.js、Promise、generator 和 异步函数。

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

---

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

• 使用 npm

• npm 的诀窍和最佳实践

• 语义化版本及发布模块

• 理解模块系统、CommonJS 和 require

• Node.js 深度探索

• Node.js 的事件循环

• Node.js 的垃圾回收机制

• 写原生 Node.js 模块

• 构建

• 高级 Node.js 项目结构

• JavaScript 整洁代码最佳实践

• Node.js 异步最佳实践 (本文)

• 事件来源与示例

• 命令查询责任隔离

• 测试

• 单元测试

• 端到端测试

• 生产环境的 Node.js

• 监控 Node.js 应用

• 调试 Node.js 应用

• 分析 Node.js 应用

• 微服务

• 请求签名

• 分页式跟踪

• API 网关

---

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。这个处理器中需要进行三个步骤：validateParams、dbQuery 和 serviceCall。

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

// 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 系列的一个部分继续了解 示例讲解事件来源