Javascript Promises
Published: 2020-07-20 04:11:24

A *promise* is an object that can potentially turn into a value in the future. The value will either be resolved or unresolved and if it does resolve it will be either resolved, rejected or pending. A better example of this would be to conceptually think of a promise in javascript just like a promise you might make to someone in real life. When you make that promise it will either be unresolved or resolved. While waiting for the promise to be fulfilled it has three stages of existence as mentioned previously: resolved, rejected or pending.

###**Stages of a Promise** 
 **Resolve**: the promise will have a value 
 **Reject**: the promise has failed
 **Pending**: the stasis period of waiting for the promise to receive either of the two previously mentioned states.



###**Example of a Promise**
````javascript 
 let firstPromise = new Promise(function(resolve, reject) {
  setTimeout(function() {
      resolve('I will only eat one cookie');
  }, 2000);
});

firstPromise.then(function(data) {
  console.log(data); //will log 'I will only eat one cookie' after two seconds
});

```
Promises have become the standard way to deal with asynchronous code. Asynchronous coding models let multiple code blocks execute at the same time. It allows for new actions to start while the program is being ran. In the example the *firstPromise* is using *resolve* to fulfill the promise. After we use the *then* function to bind a callback so we can use the data from the resolve function. It is possible to bind multiple callbacks too!

````javascript
var indecisivePromise = new Promise(function(resolve, reject) {
  setTimeout(function() {
      resolve('I will only eat one cookie');
  }, 2000);
});

indecisivePromise.then(function(data) {
  console.log(data + ' hopefully.');
});

indecisivePromise.then(function(data) {
  console.log(data + ' maybe.');
});

indecisivePromise.then(function(data) {
  console.log(data + ' I make no promises.');
});

```
Promises can only be resolved once. The method *then* can be chained but there can only be one resolve. Just like in real life once a promise has been fulfilled you can not fulfill the same promise for a second time unless you have another condition to the promise. That's why the *then* method is useful. IT 

````javascript
let multiResolvePromise = new 

Promise(function(resolve, reject) {

  setTimeout(function() {

//only this will revolve
      resolve('first resolve');

//the promise ends after the first resolve
      resolve('second resolve');
      resolve('third resolve');
      resolve('fourth resolve');
  }, 1000);
});


multiResolvePromise.then(function success(data) {
  console.log(data); //will print 'first resolve'
});
```

What happens if the promise is not fulfilled? The *catch* method allows us to have an output if the promise fails.

```javascript 
const failedPromise = new Promise((resolve, reject) => {

  let numberOfCookies = 1000000;

  if (numberOfCookies < 1) {
    resolve('Good job you only at one cookie!')
  } else {
    reject('I knew you would eat more than one, but one million that is madness.')
  }
});

failedPromise.then((resolveData) => {
  console.log(resolveData)
}).catch((rejectData) => {
  console.log(rejectData)
});
```
Since the conditional statement above is false the promise fails so the *resolve* method will not trigger thus leaving the promise unfulfilled. 

###Conclusion
Promises allow for coding asynchronously to be easier to understand and avoid using more complicated programming strategies. Promises will either resolve or reject depending on the criteria of the promise object. Once the promise is pending we can then chain then and catch to implement more intuitive asynchronous code instead of venturing into a "callback hell". If we were to use a lot of callbacks the code would be extremely hard to follow and become unruly making errors and debugging much harder to do.