Network Requests: GETs and POSTs

Learning Goals

• Understand the difference between synchronous and asynchronous operations
• Be familiar with the fetch API
• Understand how network requests work
• Know what GET and POST requests do and how to use them

Vocab

• Async / Asynchronous Executing code without blocking the execution of code after it
• AJAX Updating a webpage based on data from the network without reloading the whole thing

What is a network request?

Let’s start by reviewing what a network request is and see it in action!

Types of Requests

Network requests can be made to GET information from a server, but it’s not the only use.

The HTTP protocol defines a variety of types of requests we can make. These include:

• GET - retrieve information from a server
• POST - send information to a server, creating resources
• PUT - send information to a server, updating entire resources
• PATCH - send informatin to a server, updating partial resources
• DELETE - remove information from a server
• And many others

Today we’ll be focusing on how to do GET and POST requests on the frontend side.

Responses

Every request we make, successful or not, will receive a response. When looking at the Network tab in the dev tools, you might have noticed some requests had different respond codes. The HTTP protocol lays a series of Response Codes to give more information on the status of a request.

Making A Request

Each network request takes time - they’re expensive. Imagine if you had to wait for a webpage to load one thing at a time! It would not make for a great user experience.

Network requests are expensive no matter what we do. However, we can run them asynchronously, saving some time.

Asynchronous operations refer to things that can happen outside the normal order of execution. Network requests can be synchronous or asynchronous, but most modern applications do them asynchronously to improve performance / the user experience.

ES6: fetch()

Speaking of using the fetch API, let’s take a look at the docs on what it is!

fetch(resourceUrl, {/*init object with `method`, `body`, and other optional properties*/});
// Returns a promise

GET with fetch

By default, fetch performs a GET request. This means that if we only add a resource url to the fetch call, we’ll try and GET information from that resource.

fetch("https://opentdb.com/api.php?amount=1&category=27&type=multiple");

fetch("https://opentdb.com/api.php?amount=1&category=27&type=multiple")
  .then(response => console.log(response))

fetch("https://opentdb.com/api.php?amount=1&category=27&type=multiple")
  .then(response => response.json())
  .then(data => console.log(data));

fetch("https://opentdb.com/api.php?amount=1&category=27&type=multiple")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => /* do something else */);

POST with fetch

What if we want to add information to a database?

If we want to use fetch to make any other kind of request, we’ll have to add an optional init object into the function call.

fetch(url, {
  method:"POST",
})

From here, the implementation may look different based on the API you’re communicating with. Some good init object properties to be aware of:

• method - whatever kind of request we’ll be making; “GET”, “POST”, “DELETE”, etc…
• body - the body of whatever we want to send to the server
• headers - extra information needed about the request. Takes an object. An important header property to know:
  • Content-Type - specify what format the body will be in

Here’s a typical POST request structure:

fetch(url, {
  method: 'POST',
  headers: {
  	'Content-Type': 'application/json'
  },
  body: JSON.stringify(someDataToSend), // remember how HTTP can only send and receive strings, just like localStorage?
})
  .then(response => response.json())
  .then(json => /*do something with json*/)
  .catch(err => /*do something with the error*/);

Remember, fetch still returns a promise. We’ve got to resolve it, regardless of what request type we’re making.

Often times, if a POST is successful, you’ll see a 201 created status message in the response

Nice to Know: Query Strings / URL Structure

What’s all that weird stuff in the URL we’re fetching?

Fetch and XMLHttpRequest Objects take the url as one of their arguments. The URL itself can be thought of containing sub-arguments that give these request objects and methods more information. The entire anatomy of a URL can be broken down into a series of informative peices, but the ones we’re focused on today are queries.

Anything coming after the ? in a url is part of a query. Queries can be broken down into categories and arguments (check the vocab here). Each category / argument pair is separated by an &.

In the example from above:

fetch("https://opentdb.com/api.php?amount=1&category=27&type=multiple")

we’re querying information about the amount, category, and type of the trivia we want to receive.

Promises

“A Promise is an object representing the eventual completion or failure of an asynchronous operation”

In our case, we can think of Promises as a placeholder that will do something once it receives a response back from the trivia server.

The great thing about promises is that since they are just objects we can move them around like an object and can return them from functions.

function getTrivia(number, categoryId) {
  const root = 'https://opentdb.com/api.php';
  const url = `${root}?amount=${number}&category=${categoryId}&type=multiple`;
  const promise = fetch(url)
                  .then(response => response.json());
  
  return promise;
}

getTrivia(10, 27)
  .then(data => console.log(data))
  .catch(err => /* do something else */);

What is this asynchronous thing all about?

Let’s say we’re at a restaurant for a night out on the town…Here’s how the experience would go in each scenario:

• Synchronous: I order my food, everyone in the restaurant has to wait until I get my food before the next person can order.

• Asynchronous: I order my food, the order is put into a queue, other food is made in the meantime, my food is ready, and the server brings it to me.

A Non-AJAX Example: setTimeout()

console.log("Legen...");

setTimeout(() => {
  console.log("DARY!");
}, 2000);

console.log("Wait for it...");

setTimeout() is actually an asynchronous function, which executes its callback after waiting for the allotted time to expire.

Further Reading:

• The Evolution of Asyncronous JavaScript
• Fetch
• Promises
• Postman – good tool for testing out APIs
• GETs, POSTs and DELETEs, man! Intro to Postman - Instructor video for getting started with Postman