Now you're going to learn how to create a promise and get a result out of a promise,

then how to chain promises together.

A promise is always going to be in one of three possible states,

pending, fulfilled, or rejected.

The pending state is like the waiting state you're in after being handed

the pager.

It's the default state of a promise.

Fulfilled means that the operation completed successfully.

And rejected means that the operation failed.

Working with promises is a three step sequence.

You create a promise instance using the Promise() constructor.

You then define what should happen when the promise is fulfilled or rejected.

Then call one of the methods provided by the promise API to either consume

the value of a fulfilled promise, or provide a rejection reason for

a rejected promise.

Let's see how all of this works.

In the project, open the file promises-breakfast.js.

In this file, let's create a new promise called breakfast promise

with const breakfastPromise.

We create the promise using the new keyword,

followed by the Promise() constructor function.

The Promise() constructor takes one argument,

a callback with two perimeters, resolve for

when the promise is fulfilled, and reject for when it's rejected.

Within the callback, I'll write an async task using the setTimeout method.

I'll pass it a callback and set a delay value of 3,000 milliseconds, or 3 seconds.

Our Promise() constructor function is all set up.

This function is going to return a promise object that is either pending,

resolved, or rejected.

For example, if I console.log(breakfastPromise),

then in the terminal run this file with node promises-breakfast.js,

notice how the console outputs a promise object, which is currently pending.

And that's correct because pending is the default state of a promise.

So now, inside the constructor, we can either call resolve to

return a promise object that is resolved with a given value, or

reject to return a promise object that is rejected with a given reason.

Both of these functions are provided by the constructor.

So first, inside setTimeout, I'll call resolve.

And resolve does just that, it changes or

resolves the status of the promise from pending to fulfilled.

We can pass resolve a value which then becomes the fulfillment value of

the promise.

For example, I'll pass resolve the string Your order is ready, come and get it!

So when the asynchronous task completes successfully, it's going to return

a resolved promise object with Your order is ready, come and get it as its value.

Running the file again in the console,

we see that the promise is in a pending state.

So now we need to get the value out of the promise object, or consume the promise.

To do that, the Promise API offers methods you can call on the promise.

The two you'll likely use most are then() and catch().

So first, I'll call then() on our breakfast

promise with breakfastPromise.then.

then() can be called to handle both fulfilled and rejected promises.

It accepts two functions as its argument, one for fulfilled promises, and

an optional one for rejected promises.

In this case, I'm only calling it to handle fulfilled promises, and

later use the catch method to handle rejected promises.

So to get the resolved value, I'll pass then() an arrow function that takes

the fulfillment value as a parameter I'll name val, and logs it to the console.

Now I'll run this file again in the console,

we see that the promise is pending.

Then after three seconds, it resolves to the value Your order is ready, come and

get it.

Good, so after the three second delay, the promise changes from pending to fulfilled.

Then the function passed to then() is immediately invoked,

which returns the fulfillment value.

In other words, whatever we pass the resolve method is

available to be used here inside then.

Not all promises are resolved, so in the next video,

you'll learn how to handle rejected promises using the catch() method.