Can I ignore a promise in javascript?

Question

I have a promise/deferred set up for my web worker where the main thread makes a change in the web worker's data and tells me to recalculate. I have a promise to call it back upon completion.

However, in mid process the main thread can make an additional change, again with the promise to call back upon completion. (This interrupt can occur because the web worker makes a setTimeout call at times to allow interruptions.) At this point the web worker holds 2 promises to the main thread, both of which will return the exact same value.

Is it ok to throw away the first promise and only call back on the second. The code will all run fine and the main thread logic will be great (better in fact) with just the one call back. Is there any problem with doing this?

The promise is just a function stored in an object I'm holding in a hashtable. So if I remove it from the hashtable its memory should be returned to the heap and so there should be no leak of any kind.

So can I make my callback system a liar (when appropriate)?

Answer 1

This is perfectly legitimate. As Ben points out in the comments, in cases like autocomplete it's very common. In fact, I wrote a library explicitly designed to support this kind of thing:

https://github.com/domenic/last

To quote from its readme:

var last = require("last");

var smartSearch = last(doSearch);

$(searchEl).on("input", function (ev) {
    smartSearch(searchEl.value).then(updateUIWithResults).done();
});

The wrapped function will return a promise of the same type as that returned by the original. And once you call the wrapped function again, you will be guaranteed that previously-returned pending promises stay pending forever, so you don't have to worry about them coming back later than your new promise.