Function 在返回后继续执行

Question

My question is simple, when I run the following code and check the DB, I find that the user is deleted successfully, that means the User.findOneAndDelete is executed, promise is fulfilled and I expect to see { success: 'user_deleted' } in the response; however, I am getting { error: 'user_not_found' } which is supposed to happen ONLY if User doesn't exist which isn't the case here because the code inside the IF block is executed as per my observation in the DB.

User.exists({ username}).then(exists => {
    if (exists) {
      User.findOneAndDelete({ username }).then(() => {
        res.json({ success: 'user_deleted' });
        return;
      }
      ).catch(err => {
        res.json({ error: 'user_delete_fail' });
        return;
      })
    };
    res.json({ error: 'user_not_found' })
    return;
  });

Now to solve this I tried to add an else statement instead of the implicit way I was doing it before, and it worked as expected and I got `{ success: 'user_deleted' } in the response.

User.exists({ username}).then(exists => {
    if (exists) {
      User.findOneAndDelete({ username }).then(() => {
        res.json({ success: 'user_deleted' });
        return;
      }
      ).catch(err => {
        res.json({ error: 'user_delete_fail' });
        return;
      })
    } else {
      res.json({ error: 'user_not_found' })
      return;
    };
  });

My question is: Why is this behavior happening? Why is execution jumping to the bottom of the function already? And why when it goes to the bottom of the function and responds, how does the delete occur and the User is deleted in the DB, I am quite confused here.

EDIT: It also behaves as expected when I convert the parent function to an async function and use await on the DB operation.

Answer 1

The problem with your code is the last res.json({ error: 'user_not_found' }) call.

If you look carefully, this line is getting fired even before the inner delete query is fired as inner query is asynchronous.

So in first scenario the function always returns the response regardless user exists or not.

putting else in your code block basically performs either this or that logic so if user exists, res.json({ error: 'user_not_found' }) will never get called.

EDIT: Alternative Code Using Async-Await

Using async-await in this case would make more sense as it simplifies the code, check following code which should do exactly what you want without use of else .

It also avoids nesting which makes code simpler

User.exists({ username }).then(async exists => {
    try {
        if (exists) {
            // this await will remove the need of inner promise chaining
            await User.findOneAndDelete({ username });
            res.json({ success: 'user_deleted' });
        }
        // in this case, this will no longer be performed before delete query
        res.json({ error: 'user_not_found' });
    } catch (error) {
        res.json({ error: 'user_delete_fail' });
    }
});

PS - You can have similar async-await for User.exists API provided its parent function is marked as async .

I hope this helps.

Answer 2

findOneAndDelete returns a Promise , which will not block the execution of the remaining code (except when, as you pointed out, the function is async and you await it). Furthermore you are not returning from the if branch ( return inside the then will only return from the callback in then ) and thus the remaining code outside will be executed either way. It probably only works if you await (without return ) because the response is already sent at the point.