Might a promise be garbage collected too early without a .then() in JavaScript

Question

So basically I want to asynchronously execute 2 synchronous promises. Like so:

(function foo() {
  var newValues = ...;
  this.getMessages().then((msgs: Array<any>) => {
    this.saveMessages(msgs.concat(newValues));
  });
})()

Now since I don't want to wait for saveMessages to finish execution I didn't add a .then() at the end. Since I don't care about the result. I just want to async function to execute so at some point we have the messages offline.

BUT I fear that the promise might get garbage collected since by the standard (as far as I know) you always need a .then for promises.

So my question is whether I need to add an empty .then to make sure it's not garbage collected too early and the function wouldn't execute correctly. Like so: this.saveMessages(msgs.concat(newValues)).then();?

And is it the same in the browser and NodeJS?

Answer 1

BUT I fear that the promise might get garbage collected since by the standard (as far as I know) you always need a .then() for promises.

No. There does not exist any such standard -- to my knowledge -- which states that the GC will free up the memory allocated to the a Promise object if a .then() is not attached to it.

Promises will get executed regardless of whether a .then() -- or a .catch() for that matter -- is attached to it.

So my question is whether I need to add an empty .then() to make sure it's not garbage collected too early and the function wouldn't execute correctly.

No you do not need an empty .then()

And is it the same in the browser and NodeJS?

Yes, as long as you use same Promise implementation on both the runtimes.

---

So, you would be completely fine with this:

function foo() {
  var newValues = ...;
  this.getMessages().then((msgs: Array<any>) => {
    this.saveMessages(msgs.concat(newValues));
  });
}

But, You should consider attaching a .catch() to it to handle any errors. If you don't, you will have UnhandledPromiseRejectionWarning. In future versions of Node, it can crash your whole app. Read about it here

EDIT

Even if the parent has nothing to process or execute, the program will wait till each of the 100 promises has resolved. Try this:

const n = 100;

const sleep = (id, seconds) =>
    new Promise(resolve => {
        setTimeout(() => {
            console.log(`promise with id ${id} is resolving`);
            resolve();
        }, seconds * 1000);
    });

for (let i = 0; i < n; i++) {
    sleep(i, 1 * i);
}

console.log("Last line of parent");

Answer 2

you can use this code and return your first promise and second promise is run sync.

function foo() {
  var newValues = ...;
  return this.getMessages().then((msgs: Array<any>) => {
    this.saveMessages(msgs.concat(newValues));
  });
}

Answer 3

No, the Promise knows nothing about how you're handling its completion until it gets there.

You don't need to worry about garbage collection preemptively, Javascript is smarter than that, but you do have to worry about the global execution context completing, as in, your program closing the connection, before the Promise has resolved, which would then cancel the promise and perform garbage collection.

Since you're running it asynchronously, if you want to guarantee the program awaits the completion of that Promise without making everything synchronous you can always hold the completion state of the Promises on a scoped variable or use an event emitter...

var imDone = false;

function foo() {
  var newValues = ...;
  this.getMessages().then((msgs: Array<any>) => {
    this.saveMessages(msgs.concat(newValues))
         .catch(err=> { console.log(err); imDone = true; })
         .then(()=> imDone = true);                           
  }).catch(err=> console.log(err));
}

....

if (imDone) {
  // finish execution, res.send() or res.end() in Node
} 

Answer 4

You are not executing the code in the right way. Promises should be handled in the right way.There is no issue with the garbage collector freeing up the space. Your code can be written in this manner which would increase the readability and make the code easier to understand.

// This is pseudo synchronous execution of the code
function foo() {
  var newValues = 'testing';
  return this.getMessages()
  .then((msgs: Array<any>) => {
    // here return is important
    return this.saveMessages(msgs.concat(newValues));
  });
}

You can reduce the complexity by using async/await feature:

aync function foo() {
    try {
        var newValues = 'testing';
        const msgs = await this.getMessages()
        await this.saveMessages(msgs.concat(newValues))
    } catch (ex) {
        // handle your error here
    }
}