使用快速路由处理程序和Promise-最佳做法是什么？

Question

I'm currently working on a web project and I'm trying to understand Node.js and express. I know about that for achiving asynchronous easy to maintain code we should use promises , but I'm confused about the following scenario: I have a route handler for REST API , should I return a promise ? even if there is no Async work done there ? ie :

dummy_router.post("/", passport.authenticationMiddleware(), (req, res) => {
  return new Promise((fulfill, reject) => {
      var result = some_simple_functionality();
      if (result) {
          fulfill(result)
      } else {
          reject(err)
      }

  }).catch(function (error) {
      res.status(400).send('400: failed t :: ' + error + '\n');
  });
});

also second question on same issue . if I am performing some async tasks and have promises containing them then is this a good practice ?

dummy_router.post("/", passport.authenticationMiddleware(), (req, res) => {
  some_promise().then((result) => {

  }, (err) => {

  }).catch(function (error) {
    res.status(400).send('400: failed t :: ' + error + '\n');
  });
});

Answer 1

Turning my comments into an answer:

Your first example is manufacturing a promise when none is needed. There is no reason to wrap synchronous code in a promise. That just adds complexity that is not needed and adds no benefit. Express does not do anything with the return value from a request handler so there is no use in returning a promise from that at all.

Your second example appears to be using an actual asynchronous operation that returns a promise. That looks generally correct, but it is unclear why you have both an error handler on your .then() and a .catch(). Pick one or the other and be aware that a reject handler that does not rethrow or return a rejected promise will change the promise into a fulfilled promise (overriding the rejection).

So, when you do this:

  some_promise().then((result) => {

  }, (err) => {
      // unless you rethrow here, this will "handle" the error
      // and the promise will become fulfilled, not rejected
  }).catch(function (error) {
      res.status(400).send('400: failed t :: ' + error + '\n');
  });

The (err) => {} handler is causing your promise rejection to get eaten unless you rethrow or return a rejected promise from that.

So, probably all you want is this:

  some_promise().then((result) => {
      // code to process result here
      res.send(...);
  }).catch(function (error) {
      res.status(400).send('400: failed t :: ' + error + '\n');
  });

There is rarely ever a reason to use both a .then() reject handler (the 2nd argument to .then() and a subsequent .catch() handler.

Is there justification to use both the rejection handler and the catch() then?

No. There are a few uncommon situations why you might want both, but in this case (and in most cases), just having the .catch() handler is all you need.