Why does the Promise constructor need an executor?

by

This is called the revealing constructor pattern coined by Domenic.

Basically, the idea is to give you access to parts of an object while that object is not fully constructed yet. Quoting Domenic:

I call this the revealing constructor pattern because the Promise constructor is revealing its internal capabilities, but only to the code that constructs the promise in question. The ability to resolve or reject the promise is only revealed to the constructing code, and is crucially not revealed to anyone using the promise. So if we hand off p to another consumer, say

The past

Initially, promises worked with deferred objects, this is true in the Twisted promises JavaScript promises originated in. This is still true (but often deprecated) in older implementations like Angular’s $q, Q, jQuery and old versions of bluebird.

The API went something like:

var d = Deferred();
d.resolve(); 
d.reject();
d.promise; // the actual promise

It worked, but it had a problem. Deferreds and the promise constructor are typically used for converting non-promise APIs to promises. There is a “famous” problem in JavaScript called Zalgo – basically, it means that an API must be synchronous or asynchronous but never both at once.

The thing is – with deferreds it’s possible to do something like:

function request(param) {
   var d = Deferred();
   var options = JSON.parse(param);
   d.ajax(function(err, value) { 
      if(err) d.reject(err);
      else d.resolve(value);
   });
}

There is a hidden subtle bug here – if param is not a valid JSON this function throws synchronously, meaning that I have to wrap every promise returning function in both a } catch (e) { and a .catch(e => to catch all errors.

The promise constructor catches such exceptions and converts them to rejections which means you never have to worry about synchronous exceptions vs asynchronous ones with promises. (It guards you on the other side by always executing then callbacks “in the next tick”).

In addition, it also required an extra type every developer has to learn about where the promise constructor does not which is pretty nice.

More Related Contents:

  1. How to return many Promises and wait for them all before doing other stuff
  2. Why does .json() return a promise?
  3. async/await always returns promise
  4. How to turn this callback into a promise using async/await?
  5. Asynchronous exception handling with bluebird promises
  6. What is the difference between JavaScript promises and async await?
  7. How to wait for a JavaScript Promise to resolve before resuming function?
  8. Should an async API ever throw synchronously?
  9. Node JS Promise.all and forEach
  10. $.Deferred: How to detect when every promise has been executed
  11. How to async await in react render function?
  12. What does $.when.apply($, someArray) do?
  13. Why can I not throw inside a Promise.catch handler?
  14. How to block for a javascript promise and return the resolved result? [duplicate]
  15. using async await and .then together
  16. How to implement a pseudo blocking async queue in JS/TS?
  17. Are JavaScript Promise asynchronous?
  18. How to return from a Promise’s catch/then block?
  19. Javascript – if with asynchronous case
  20. Using mongoose promises with async/await
  21. What are asynchronous functions in JavaScript? What is “async” and “await” in JavaScript?
  22. map() function with async/await
  23. How to use Promise.all with an object as input
  24. Javascript Asynchronous Exception Handling with node.js
  25. Why are javascript promises asynchronous when calling only synchronous functions?
  26. Produce a promise which depends on recursive promises
  27. When does async function actually return a pending promise?
  28. Properly batch nested promises in Node
  29. JavaScript asynchronous programming: promises vs generators
  30. Promise.all is returning an array of undefined and resolves before being done

Leave a Comment