Promises

Question 1

What does a promise represent?

Answer 1

A promise represents the completion of an asynchronous function.

It is an object representing the eventual completion or failure of an asynchronous operation.

Question 2

Prior to promises, how did we get around the problems that single-thread presents?

Answer 2

Usually events and callbacks.

Question 3

What are the possible result states of a promise?

Answer 3

A promise can be:

fulfilled - The action relating to the promise succeeded
rejected - The action relating to the promise failed
pending - Hasn’t fulfilled or rejected yet
settled - Has fulfilled or rejected

Question 4

How many arguments does a then() take?

Answer 4

then() takes two arguments, a callback for a success and another for a failure case. Both are optional, so you can add a callback for the success or failure case only.

Question 5

Where can I find more info on promises?

Answer 5

At the following url for one:

https://developers.google.com/web/fundamentals/primers/promises

Question 6

What is the syntax for creating a promise?

Answer 6

new Promise((resolve, reject) -> {})

Question 7

When is a promise pending?

Answer 7

Until you give the promise something to resolve/reject, it will sit there as pending with a value of undefined.

Question 8

When is a promise settled?

Answer 8

Once a promise is resolved/rejected, it is settled.

Question 9

What are callbacks?

Answer 9

Callbacks are functions that have been passed as arguments to other functions.

Question 10

What is promise chaining?

Answer 10

A common need is to execute two or more asynchronous operations back to back, where each subsequent operation starts when the previous operation succeeds, with the result from the previous step.

With promises, we accomplish this by creating a promise chain. The API design of promises makes this great, because callbacks are attached to the returned promise object, instead of being passed into a function.

Question 11

What is the most intuitive way of handling promises?

Answer 11

Using async/await can help you write code that’s more intuitive and resembles synchronous code.

Question 12

In a promise chain, what does each promise represent?

Answer 12

In a promise chain, each promise represents the completion of one asynchronous step in the chain. In addition, the arguments to then are optional, and catch(failureCallback) is short for then(null, failureCallback) — so if your error handling code is the same for all steps, you can attach it to the end of the chain (as one catch-all so to speak).

Question 13

Can you have a then after a catch in a promise chain?

Answer 13

Yes, it’s possible to chain after a failure, i.e. a catch, which is useful to accomplish new actions even after an action failed in the chain.

Question 14

What happens if a promise rejection event is not handled by any handler?

Answer 14

If a promise rejection event is not handled by any handler, it bubbles to the top of the call stack, and the host needs to surface it.

Question 15

What are the composition tools for running async operations together?

Answer 15

There are four composition tools for running asynchronous operations concurrently:

Promise.all()
Promise.allSettled()
Promise.any()
Promise.race().

Question 16

What is a Promise.all()?

Answer 16

The Promise.all() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when all of the input’s promises fulfill (including when an empty iterable is passed), with an array of the fulfillment values. It rejects when any of the input’s promises rejects, with this first rejection reason.

Question 17

What is a Promise.allSettled()?

Answer 17

The Promise.allSettled() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when all of the input’s promises settle (including when an empty iterable is passed), with an array of objects that describe the outcome of each promise.

Question 18

What is a Promise.any()?

Answer 18

The Promise.any() static method takes an iterable of promises as input and returns a single Promise. This returned promise fulfills when any of the input’s promises fulfills, with this first fulfillment value. It rejects when all of the input’s promises reject (including when an empty iterable is passed), with an AggregateError containing an array of rejection reasons.

Question 19

What is a Promise.race()?

Answer 19

The Promise.race() static method takes an iterable of promises as input and returns a single Promise. This returned promise settles with the eventual state of the first promise that settles.

Question 20

What is an example of an old-style API that still expects success and/or failure callbacks to be passed?

Answer 20

The most obvious example is the setTimeout() function:

setTimeout(() => saySomething(“10 seconds passed”), 10 * 1000);

Question 21

If a callback to SetTimeout fails, can the error be caught?

Answer 21

Luckily we can wrap setTimeout in a promise. The best practice is to wrap the callback-accepting functions at the lowest possible level, and then never call them directly again:

const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

wait(10 * 1000)
.then(() => saySomething(“10 seconds”))
.catch(failureCallback);

Question 22

What is another name for callback hell?

Answer 22

Pyramid of doom.

Question 23

What is the superpower of promise chains?

Answer 23

Each function will only be called when the previous promise has resolved, and it’ll be called with that promise’s output.

Question 24

What things can you do in a then statement?

Answer 24

1. return another promise
2. return a synchronous value (or undefined)
3. throw a synchronous error

Question 25

What should you always do in a then function?

Answer 25

You should always return or throw from inside a then() function.

Question 26

How can the normal new Promise declaration containing just a resolve be expressed?

Answer 26

Instead of :

new Promise(function (resolve, reject) {
resolve(someSynchronousValue);
}).then(/* … */);

you can just say:

Promise.resolve(someSynchronousValue).then(/* … */);

Question 27

Which is preferable, to use the 2nd argument to then or to use a catch?

Answer 27

The preference should be to use a catch as it will catch all errors whereas the 2nd argument to a then, may lead to an error not being reported.

Note, that this may not be the case when writing async tests in Mocha.