Essential CSS
JavaScript Roadmap
Learn JavaScript
Mastering Web Typography
Practical Astro
Understanding Async JS
Unorthodox Tailwind
API Masterclass
Build and Deploy
The Beginner Freelancer
Real World Node
Profile Billing Logout
Understanding Async JS
Lesson Plan
  1. Introduction
    1. What is Asynchronous JS?
    2. Callbacks are not automatically asynchronous
    3. What is an API?
    4. Evolution of HTTP APIs
    5. Ajax vs Asynchronous JavaScript
  2. Fundamental Concepts
    1. How to fetch resources
    2. Using XHR
    3. Using the Fetch API
    4. Using libraries
    5. Core JavaScript concepts
    6. Understanding Promises
    7. Understanding Async Functions
    8. Understanding the Event Loop
    9. Understanding JSON
    10. Async JS Best Practices
    11. Using Optimistic UI
  3. Understanding Rest API
    1. Diving into Rest APIs
    2. The Rest Architecture
    3. The Rest Structure
    4. Anatomy of a Request
    5. What's an endpoint
    6. Request methods
    7. Understanding request headers
    8. Understanding the request body
    9. Authentication
    10. Basic Authentication
    11. Bearer Authentication
    12. Authenticating with API keys and API Secrets
    13. Cross Origin Resource Sharing
    14. Anatomy of a response
    15. HTTP Statuses
    16. Response headers
    17. The response body
    18. Handling Errors
    19. Reading API documentations
    20. Understanding Curl
  4. Node Basics
    1. Why we are using Node
    2. Command Line Basics
    3. Installing Node
    4. Managing dependencies
    5. Using ES Modules in Node
    6. Using Node
    7. Restarting the server automatically
    8. Sending requests via Node
    9. Protecting API keys and secrets
  5. Building a server
    1. What's a server
    2. Building a simple server with Express
    3. Two kinds of servers
    4. API Server architecture
    5. Handling routes
    6. Understanding Middlewares
    7. Enabling CORS
    8. Receiving data
    9. Sending responses
    10. Handling errors in Express
    11. Using the server as a proxy
    12. Minimum viable server
  6. Open Authorization
    1. Open Authorisation (OAuth)
    2. Authenticating with Access Tokens
    3. Obtaining Access Tokens
    4. Public and Confidential Clients
    5. Authorisation Code Grant
    6. Understanding scope
    7. Proof Key for Code Exchange (PKCE)
    8. PKCE with Twitter
    9. Dynamic state and `code_verifier`
    10. Saving the access token in cookies
    11. Passing access tokens to the browser
    12. Saving the access token in local storage
    13. Refresh Token Grant
    14. Device Code Grant
    15. Client libraries vs REST
  7. Building Social Media Logins
    1. Introduction
    2. Starter Files
    3. Creating SSL certificates
    4. Login in with Github
    5. Github: Saving the token to local storage
    6. Github: Persisting the login status
    7. Login with Twitter
    8. Twitter: Saving the token to local storage
    9. Twitter: Persisting the login status
    10. Twitter: Refreshing the access token
    11. Login with Facebook
    12. Facebook: Saving the token to localStorage
    13. Facebook: Persisting the login status
    14. Facebook: Refreshing the access token
    15. Login with google
    16. Google: Saving the token to localStorage
    17. Google: Refreshing the access token

Understanding Promises

3m:56s

Promises are simple. You’ve already seen them at work in the Fetch API.

In this chapter, you’re going to learn everything you need to know about promises to use Async JS fluently and effectively.

Let’s go.

What is a Promise?

A JavaScript Promise is like a promise in real life.

Let’s say I promised to buy you a cake for your birthday tomorrow.

My promise can have three states:

  • Pending: You don’t know whether I’ll buy a cake yet. You’ll only know when I show up at the party (with or without the cake).
  • Resolved or Fulfilled: I showed up with the cake! 🥳
  • Rejected: I did not show up with the cake 😞.

A JavaScript Promise has the same three states too:

  • Pending: Still waiting for resolution or rejection
  • Resolved: Promise is successfully resolved
  • Rejected: Promise is unsuccessful and gets rejected.

To put it simply, a JavaScript promise is an if/else statement that will happen later — you don’t know whether it will be resolved or rejected until that time (or event) comes.

Basic Promise Usage

Here are some rules around using promises.

Handling promise resolution and rejection

All promises have then and catch methods.

  • We act on resolved promises in then.
  • We can act on rejected promises in catch.

Let’s say I turned up to the party with the cake. In this case, we get to eat the cake. So eating the cake will take place in the then method.

bringCake().then(cake => eatCake)

Now, instead of depending on me to turn up with the cake, you may also have a backup plan (in case I fail to bring the cake).

If I did not show up with the cake, a simple backup plan would be to go and buy a cake together.

bringCake()
.then(cake => eatCake)
.catch(error => goAndBuyCake) // Promise rejected. Backup plan invoked

Then statements can be chained

If you return a value in then, you can use that returned value in the next then.

somePromise()
.then(_ => 50)
.then(data => console.log(data)) // 50

The Fetch API uses this feature since we have to convert the ReadableStream into JSON with response.json.

fetch('https://link-to-resource')
.then(response => response.json())
.then(data => {/* do something with data */}

Catching Errors

Typically, we will use a catch at the end of the promise chain to handle errors.

We can do this because any errors that occur in a promise will jump straight to the next catch method. It will skip any then methods along the way.

somePromise()
.then(face => new Error('🙁')) // Throws an error
.then(face => console.log(face)) // Skips this line
.catch(face => console.log(face)) // Jumps to this line. Result: Error 🙁

Finally

All promises have a finally method. This method will be called after all then and catch calls.

somePromise().then(/*…*/).catch(/*…*/).finally(/*…*/)

Personally, I haven’t had much use for the finally method. That said, it’s still good to know this method exists in the event you need it.

The Promise Constructor

You can use the Promise constructor to create a promise.

const promise = new Promise(callback)

You don’t need to create promises most of the time. It’s usually meant for advanced use cases (like if you build a wrapper library around the Fetch API 🙃).

So you only have to read this section if you’re interested in a thorough understanding of things.

Creating a promise

Each Promise constructor contains a callback with two arguments — resolve and reject.

const promise = new Promise((resolve, reject) => {
// Do something with resolve and reject
})

Next, we need to determine whether the promise resolves or rejects.

The easiest way is to use an if/else condition in the promise we just created.

  • If the condition returns true, we resolve the promise.
  • If the condition returns false, we reject the promise.
const promise = new Promise((resolve, reject) => {
if (condition) {
resolve()
} else {
reject()
}
})

Both resolve and reject take in a single argument.

  • The value passed into resolve goes into then.
  • The value passed into reject goes into catch.
const promise = new Promise((resolve, reject) => {
if (condition) return resolve('😄')
reject('🙁')
})
promise()
.then(face => console.log(face)) // 😄
.catch(face => console.log(face)) // 🙁 (if rejected)

Converting callbacks into promises

You can convert any callback into a promise — because Promises are simply callbacks written in another manner.

But that’s a lesson for another day.

No need to stress yourself trying to understand this right now. Just read this article when you need to do this.