节点和异步：为什么在子功能中不尊重等待？

Question

我是一名 Node.js 学生，正在编写一个简短的示例。 /org 上的获取按预期工作。

在 /orgg 上，我尝试将服务器“获取数据”逻辑与控制器隔离开来。但是，getRowsAsync() 会立即返回一个 Promise。

这种“将 await 放入 express.get()”不利于隐藏逻辑。如果我的 biz 逻辑需要一些顺序的 Promise，那么 biz 逻辑就必须冒泡到控制器中。

如何在控制器中调用“doBizLogic()”，隐藏我的等待，让控制器等待逻辑完成？ 必须我将回调函数传递给 biz 逻辑以使该方案有效吗？

这是我的 index.js。我省略了database.js，但我从https://mhagemann.medium.com/create-a-mysql-database-middleware-with-node-js-8-and-async-await-6984a09d49f4借来的

const express = require("express");
const urlPort = 3000;
let app = express();
let mysql = require("mysql2");
let pool = require("./database");

app.listen(urlPort, () => {
  console.log("Server is running at port " + urlPort);
});

app.get("/", (req, res) => {
  res.send("This app responds to /org and /org/:id only.");
});

app.get("/org", async (req, res) => {
  let rows = await getRows("select * from org");
  // the log always prints a JSON array.
  console.log("in app.get for /org, rows: ", rows);
  res.send(rows);
});

app.get("/orgg", (req, res) => {
  let rows = getRowsAsync();
  // the log() prints immediately prints a Promise.
  console.log("in app.get for /orgg, rows: ", rows);
  res.send(rows);
});

function getRows(sql, params = []) {
  let rows = pool.query(sql, params);
  // the log() prints a Promise.
  console.log("in getRows, rows: ", rows); // returns 
  return rows;
}

async function getRowsAsync() {
  let rows = await getRows("select * from org");
  // the log() prints a JSON array, once it is finally called.
  console.log("in getRowsAsync, rows: ", rows);
  return rows;
}

Answer 1

您的具体问题

如何在控制器中调用“doBizLogic()”，隐藏我的等待，让控制器等待逻辑完成？

你无法隐藏这个逻辑。任何“可能”是异步的 API 都必须设计为异步 API，并且调用者需要知道如何正确使用异步 API。

您无法隐藏异步性，因为 Javascript 无法将异步操作变为同步操作。如果您的操作的任何部分是异步的，那么它将需要一个异步接口来传达结果和完成（通过承诺、回调或事件）。

我必须向 biz 逻辑传递一个回调函数才能使这个方案起作用吗？

您可以使用回调，但我建议只返回一个承诺，即调用者可以使用await on，因为这是一种比回调更现代的设计，并且更易于编程，尤其是在有其他异步操作的情况下在同一个函数中。调用者必须利用返回的承诺才能正常工作。

所以，让您的来电者使用await。无论如何，调用者必须“知道”它是一个异步接口，因为您使用的异步接口与同步接口不同。

这种“将 await 放入 express.get()”并不适合隐藏逻辑。如果我的 biz 逻辑需要一些顺序的 Promise，那么 biz 逻辑就必须冒泡到控制器中。

是的，这就是 Javascript 中的方式。调用者必须知道他们是在调用同步 API 还是异步 API，以便他们知道如何获取结果/错误和完成。除非您将所有接口都设计为异步的，并将对这些 API 的所有调用都视为异步（这对于完全同步的 API 来说效率不高），否则没有任何办法。

为什么在子函数中没有执行 await？

在这段代码中：

function getRows(sql, params = []) {
  let rows = pool.query(sql, params);
  // the log() prints a Promise.
  console.log("in getRows, rows: ", rows); // returns 
  return rows;
}

代码未正确处理异步pool.query()。该函数显然返回了一个承诺，您无需等待该承诺通过await 或.then() 解决。因此，当您尝试记录该值时，您只会得到承诺。此函数将返回承诺，因此调用者可以通过在该承诺上使用 .then() 或 await 来获取值。

Await 需要正确的 promise 实现

我还要提到，为了让await 为您的调用者正常工作，您的函数必须返回一个在异步操作完成时解决或拒绝的承诺，并且任何已解决的值或被拒绝的错误也在该承诺中。因此，仅仅在一个没有返回正确连接到异步操作的承诺的函数上打一个await 是行不通的。必须正确实施承诺，await 才能完成其工作。

使用支持承诺的 mysql 版本

由于您使用的是 mysql，我强烈建议您获取为数据库实现 promise 接口的模块，这样您就可以使用 promise 进行所有异步编码，而不是普通的回调。

link 您在 2018 年的一篇文章中提出的问题显示了许多使用普通回调的 mysql 示例。我不建议使用普通回调来启动一个新项目以进行异步操作。一旦开始使用基于 Promise 的接口，您将很快学会欣赏使用基于 Promise 的接口的优势，而 Promise 是在 Javascript 中处理异步操作的现代方式。

您必须捕获所有的承诺拒绝

附：您使用的任何承诺都必须在调用链中的某个位置有一个.catch() 或一个await 和一个try/catch，这将捕获一个潜在的被拒绝的承诺。因此，所有调用异步 API 的快速请求处理程序都缺少正确的错误处理。没有那个，你会得到一个未捕获的 promise 拒绝。充其量，请求处理程序永远不会发送响应。在最坏的情况下，您的服务器将关闭。所有可能被拒绝的 Promise 都必须在代码中的某个地方捕获。

所以，是这样的：

app.get("/org", async (req, res) => {
  let rows = await getRows("select * from org");
  // the log always prints a JSON array.
  console.log("in app.get for /org, rows: ", rows);
  res.send(rows);
});

应该是这样的：

app.get("/org", async (req, res) => {
  try {
    let rows = await getRows("select * from org");
    // the log always prints a JSON array.
    console.log("in app.get for /org, rows: ", rows);
    res.send(rows);
  } catch(e) {
    console.log(e);
    res.sendStatus(500);
  }
});

或者，如果您想集中处理所有错误：

app.get("/org", async (req, res) => {
  try {
    let rows = await getRows("select * from org");
    // the log always prints a JSON array.
    console.log("in app.get for /org, rows: ", rows);
    res.send(rows);
  } catch(e) {
    console.log(e);
    next(e);          // forward to central Express error handler
  }
});

---

如果您想捕获业务逻辑中的错误以便您可以对其进行处理，但最终仍将错误返回给您的控制器函数，那么您可以catch 和rethrow：

async function getRows(params) {
  try {
      let rows = await pool.query("select * from org", params);
      console.log("in getRows, rows: ", rows);
      return rows;
  } catch(e) {
      // catch the error, log it and do whatever else you want with it
      // either return a value or rethrow some error
      //    usually, you would throw some error here
      //    so a failed operation rejects the promise
      //    this function returns
      console.log(e);
      // you can throw a different error if you want to invent
      // your own specific errors, rather than pass back db errors
      throw e;
  }      
}