我应该在以下代码中使用 promise 还是回调？

Question

我有一些路线

routes.js

var express = require("express");
var router = express.Router();

const { controllerMethod1, controllerMethod2 } = require("./controller");

router.get("/route1", controllerMethod1);
router.get("/route2", controllerMethod2);

module.exports = router;

如果我使用 promise 变量作为全局变量，它被 controller.js 中的所有方法使用。我应该为 promise 使用全局变量还是局部变量？

controller.js

const {
  serviceMethod1,
  serviceMethod2,
  serviceMethod1ByDate,
} = require("./services");

let promise; //global promise variable
const controllerMethod1 = (req, res) => {
  //let promise; local promise variable

  //This is for Callback
  if (req.query.date) {
    serviceMethod1ByDate(req.query.date, (err, result) => {
      if (err) {
        res.status(500).json({
          status: "error",
          message: "error using callback",
        });
      }
      if (result) {
        res.status(200).json({
          status: "success",
          message: "success using callback",
        });
      }
    });
  } else {
    serviceMethod1((err, result) => {
      if (err) {
        res.status(500).json({
          status: "error",
          message: "error using callback",
        });
      }
      if (result) {
        res.status(200).json({
          status: "success",
          message: "success using callback",
        });
      }
    });
  }

  // This is for Promise
  promise = req.query.date
    ? serviceMethod1ByDate(req.query.date)
    : serviceMethod1();

我应该使用方法 1 还是方法 2？如果多个用户同时请求一条或多条路由，handleResponse方法能否正常工作？

承诺的方式 1

promise
    .then((results) => {
      return res.json({
        status: "success with promise variable",
        data: results,
      });
    })
    .catch((error) => {
      return res.status(500).json({
        status: "error with promise variable",
        message: "there is no person details",
      });
    });

Promise 方式 2

  handleResponse(promise, res);

//this method is working for all routes when i use promise
const handleResponse = (results, response) => {
  results
    .then((result) => {
      return response.json({
        status: "success with promise variable in handleResponse",
        data: result,
      });
    })
    .catch((error) => {
      return response.status(500).json({
        status: "error with promise variable handleResponse",
        message: "Internal Server Error",
      });
    });
};

controller.js

const controllerMethod2 = (req, res) => {
  //------------------ Using Callback Method -------------
  serviceMethod2((err, result) => {
    if (err) {
      res.status(500).json({
        status: "error",
        message: "error using callback",
      });
    }
    if (result) {
      res.status(200).json({
        status: "success",
        message: "success using callback",
      });
    }
  });

  //------------------ Using Promise Method -------------
  //local variable
  let promise;
  promise = serviceMethod2();

  //Way 1 for Promise
  promise
    .then((result) => {
      //...
    })
    .catch((err) => {
      //...
    });

  //Way 2 for Promise
  handleResponse(promise, res);
};

module.exports = { controllerMethod1, controllerMethod2 };

service.js

const pool = require("../../../config/database");

//-----------------------Using Callback Mehthod----------------

const serviceMethod1 = async (CallBack) => {
  let query = "select * from databse";
  await pool.query(query, [], (error, results, fields) => {
    if (error) {
      return CallBack(error);
    }
    return CallBack(null, results);
  });
};

const serviceMethod1ByDate = async (date) => {
  let query = "select * from databse where date ?";
  return await new Promise((resolve, reject) => {
    pool.query(query, [date], (error, results, fields) => {
      if (error) {
        return CallBack(error);
      }
      return CallBack(null, results);
    });
  });
};

const serviceMethod2 = async (Callback) => {
  let query = "select * from database";
  await pool.query(query, [], (error, results, fields) => {
    if (error) {
      return CallBack(error);
    }
    return CallBack(null, results);
  });
};

//-----------------------Using Promise Method----------------

const serviceMethod1 = async () => {
  let query = "select * from databse";
  return await new Promise((resolve, reject) => {
    pool.query(query, [], (error, results, fields) => {
      if (results) {
        resolve(results);
      } else {
        reject(error);
      }
    });
  });
};

const serviceMethod1ByDate = async (date) => {
  let query = "select * from databse where date ?";
  return await new Promise((resolve, reject) => {
    pool.query(query, [date], (error, results, fields) => {
      if (results) {
        resolve(results);
      } else {
        reject(error);
      }
    });
  });
};

const serviceMethod2 = async () => {
  let query = "select * from database";
  return await new Promise((resolve, reject) => {
    pool.query(query, [], (error, results, fields) => {
      if (results) {
        resolve(results);
      } else {
        reject(error);
      }
    });
  });
};

module.exports = {
  serviceMethod1,
  serviceMethod1ByDate,
  serviceMethod2,
};

Answer 1

if i use promise variable as global, its used by all method in controller.js. should i use global or local variable for promise ?

对于此类操作，您应该使用局部变量，因为全局变量通常用于定义常量或方法。它们不能用作临时值，因为它的值可以随时更改，这会导致与其他功能发生冲突，因此必须避免。

Should i use way 1 or way 2 ? if multiple users request one or more routes at the same time,can handleResponse method work correctly?

方式 2 比 方式 1 更有效，因为如果你使用 方式 1 那么您将必须为控制器中的每个方法执行此操作。 方法 2 就像一种常用方法，您可以在其中格式化您的响应，并且大多数开发人员都在使用它。

使用 callbacks 或 promises 没有任何区别，只是一种干净的做事方式。

而不是使用这个：

const serviceMethod1 = async () => {
  let query = "select * from databse";
  return await new Promise((resolve, reject) => {
    pool.query(query, [], (error, results, fields) => {
      if (results) {
        resolve(results);
      } else {
        reject(error);
      }
    });
  });
};

使用这个：

// Remove the async await from here and handle the response/error where the below method is called by putting it in try catch block.

const serviceMethod1 = () => {
  let query = "select * from databse";
  return new Promise((resolve, reject) => {
    pool.query(query, [], (error, results, fields) => {
      if (results) {
        resolve(results);
      } else {
        reject(error);
      }
    });
  });
};

// otherFile.js

someMethod = async () => {
  try {
    const result = await serviceMethod1();
    // handle the response
  } catch {
    // handle the error
  }
}

我应该在以下代码中使用 promise 还是回调？

Should i use promise or callback in the following code?

javascript

performance

callback

node.js

promise