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

Using XHR

2m:14s

To use XHR, you need to be able to do two things:

  1. Send a request with XHR
  2. Receive a response with XHR

Sending a request

There are three steps to send a request with XHR:

  1. Create an XMLHttpRequest object
  2. Create a request with the open method.
  3. Send the request with a send method.

First, you create a new XMLHttpRequest object:

const request = new XMLHttpRequest()

Second, you open a request with the open method. Here, you need to pass in an HTTP method and a url (the endpoint) to the API.

We’ll talk about HTTP methods and endpoints in a later lesson. For now, here’s what this would look like:

request.open('GET', 'https://link-to-resource')

Next, you have to send the request using the send method.

request.send()

Together, the sending process looks like this:

const request = new XMLHttpRequest()
request.open('GET', 'https://link-to-resource')
request.send()

Receiving a response

To receive a response, you have to use an event listener that listens for the load event.

request.addEventListener('load', event => {
// Do something with the response
})

Data that comes back from the response can be found in event.target.

  • If you console.log this and event.target, you will find a response property.
  • This response property contains the data.
  • This data is called the payload.

For example, you can use the following request to get a list of my repositories on GitHub.

const request = new XMLHttpRequest()
request.open('get', 'https://api.github.com/users/zellwk/repos')
request.send()
request.addEventListener('load', event => {
console.log(event.target)
})
The response property contains the data we want

In this case, GitHub sends us a JSON value in the response property.

We need to convert this value into JavaScript before we can use it.

We can do this with JSON.parse

request.addEventListener('load', event => {
const { response } = event.target
const payload = JSON.parse(response)
console.log(repos)
})
Note

JSON is one of the most important concepts you need to know to use Rest APIs today. We’ll cover what it is and how to convert from JavaScript to JSON and back in a later lesson.

Wrapping Up

Here’s the full code you need to fetch a resource with XHR.

const request = new XMLHttpRequest()
request.open('get', 'https://api.github.com/users/zellwk/repos')
request.send()
request.addEventListener('load', event => {
const { response } = event.target
const payload = JSON.parse(response)
// Do something with the payload
})

As you can see, you have to write a lot of stuff! This is why XHR is not developer friendly and many people chose to use Fetch over XHR.

Now let’s move on and learn about the Fetch API.