Are promises guaranteed to be executed?

Question

Suppose we have a simple function called logData that handles HTTP requests. Suppose, also, that we have another function called logIntoDatabase.

async logIntoDatabase(message) { ... }

async logData(request, response) {
    await logIntoDatabase("something happened");
    response("log successful");
}

Assume that we don't need to be certain that the data was logged onto the database (we don't need to wait for a response from the database). So we make a little optimization:

async logIntoDatabase(message) { ... }

async logData(request, response) {
    logIntoDatabase("something happened");
    response("log successful");
}

is it ABSOLUTLY GUARANTEED that logIntoDatabase is going to execute? (As if we waited it to be completed)

Answer 1

Yes, it is certain that logIntoDatabase is going to execute as long as the function calling it (logData) is also executed.

Note that it will not surely do what you expected it to do: it may throw an error or take a significantly long time to fully execute, although that's an issue related to the content of the function, not if you were to call it synchronously or asynchronously.

Answer 2

Script inside promise or asynchronous will always be executed unless your application/server force stop or crash.

You can read this article about how asynchronous work. Script still in stack but not blocking other process.

https://blog.bitsrc.io/understanding-asynchronous-javascript-the-event-loop-74cd408419ff

Answer 3

Are promises guaranteed to be executed?

First off, this is a bit of terminology correctness, but promises don't "execute". Asynchronous functions execute and they create promises that help you monitor their completion. You aren't calling a promise here. You're calling a function that returns you a promise.

is it ABSOLUTLY GUARANTEED that logIntoDatabase is going to execute?

Yes, if logData(...) is called, then logIntoDatabase() will always execute as the very first line in that function in both your first and second code examples.

Your method like this:

async logData(request, response) {
    await logIntoDatabase("something happened");
    response("log successful");
}

is essentially equivalent to this (assuming logIntoDatabase() returns a promise and doesn't throw synchronously):

logData(request, response) {
    return logIntoDatabase("something happened").then(() => {
        response("log successful");
    });
}

As such you can see that the very first line to execute inside logData() is your call to logIntoDatabase().

---

A full replacement for the async function would be this:

logData(request, response) {
    try {
        return Promise.resolve(logIntoDatabase("something happened")).then(() => {
            response("log successful");
        });
    } catch(e) {
        return Promise.reject(e);
    }
}

This covers other misbehaviors such as logIntoDatabase() not returning a promise or throwing synchronously. But, even in this more complete analogy, you can see that logIntoDatabase() is still guaranteed to be called.

---

In your 2nd code example:

async logData(request, response) {
    logIntoDatabase("something happened");
    response("log successful");
}

You are still guaranteed that logIntoDatabase() will be called. But, this will differ in behavior from your version with await in three ways:

1. response("log successful") will always be called even if logIntoDatabase() rejects.

2. response("log successful") will be called BEFORE logIntoDabase() finishes it's asynchronous operations.

3. The promise returned from logData() will not have any connection to whether logIntoDatabase() resolves or rejects. If neither logIntoDatabase() or resolve("log successful") throws synchronously, then the promise will be resolved with an undefined resolved value. If either does throw synchronously, then the promise returned from logData() will reject with the exception as the reason for the rejection.

So, your second example is analogous to this:

logData(request, response) {
    try {
        logIntoDatabase("something happened");
        response("log successful");
        return Promise.resolve();
    } catch(e) {
        return Promise.reject(e);
    }
}

And, you can see that logIntoDatabase() is still guaranteed to always be called.

Answer 4

Yes!

Promises in JavaScript are just like promises in real life, once one is made, it is guaranteed to be kept.

Hope this helps