Understanding JS Promises

by

About Promise resolution

The thing you’re witnessing here is called recursive thenable resolution. The promise resolution process in the Promises/A+ specification contains the following clause:

onFulfilled or onRejected returns a value x, run the Promise Resolution Procedure [[Resolve]](promise2, x)

The ES6 promise specification (promises unwrapping) contains a similar clause.

This mandates that when a resolve operation occurs: either in the promise constructor, by calling Promise.resolve or in your case in a then chain a promise implementation must recursively unwrap the returned value if it is a promise.

In practice

This means that if onFulfilled (the then) returns a value, try to “resolve” the promise value yourself thus recursively waiting for the entire chain.

This means the following:

promiseReturning().then(function(){
    alert(1);
    return foo(); // foo returns a promise
}).then(function(){
    alert(2); // will only run after the ENTIRE chain of `foo` resolved
              // if foo OR ANY PART OF THE CHAIN rejects and it is not handled this 
              // will not run
});

So for example:

promiseReturning().then(function(){
    alert(1);
    return Promise.resolve().then(function(){ throw Error(); });
}).then(function(){
    alert("This will never run");
});

And that:

promiseReturning().then(function(){
    alert(1);
    return Promise.resolve().then(function(){ return delay(2000); });
}).then(function(){
    alert("This will only run after 2000 ms");
});

Is it a good idea?

It’s been the topic of much debate in the promises specification process a second chain method that does not exhibit this behavior was discussed but decided against (still available in Chrome, but will be removed soon). You can read about the whole debate in this esdiscuss thread. This behavior is for pragmatic reasons so you wouldn’t have to manually do it.

In other languages

It’s worth mentioning that other languages do not do this, neither futures in Scala or tasks in C# have this property. For example in C# you’d have to call Task.Unwrap on a task in order to wait for its chain to resolve.

More Related Contents:

  1. How do I convert an existing callback API to promises?
  2. Async function returning promise, instead of value
  3. Use async await with Array.map
  4. Why is my asynchronous function returning Promise { } instead of a value?
  5. Correct way to write a non-blocking function in Node.js
  6. How to turn this callback into a promise using async/await?
  7. Correct way to write loops for promise.
  8. Promise – is it possible to force cancel a promise
  9. Basic Javascript promise implementation attempt
  10. When is the body of a Promise executed?
  11. return value after a promise [duplicate]
  12. ES6 Promise.all() error handle – Is .settle() needed? [duplicate]
  13. Why do I need to await an async function when it is not supposedly returning a Promise?
  14. How is a promise/defer library implemented? [closed]
  15. Promise constructor with reject call vs throwing error
  16. Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises? [closed]
  17. Using promise function inside Javascript Array map
  18. Why cant I inline call to res.json?
  19. How can I promisify the MongoDB native Javascript driver using bluebird?
  20. Proper way to skip a then function in Q Promises
  21. Why is my function returning Promise { } [duplicate]
  22. When would someone need to create a deferred?
  23. map() function with async/await
  24. How to promisify Node’s child_process.exec and child_process.execFile functions with Bluebird?
  25. How to extract data out of a Promise
  26. When does async function actually return a pending promise?
  27. Async Await map not awaiting async function to complete inside map function before mapping next item
  28. JavaScript asynchronous programming: promises vs generators
  29. How can I Interleave / merge async iterables?
  30. AngularJS Promises, $q, defer

Leave a Comment