Handling Different HTTP Methods

HTTP (Hypertext Transfer Protocol) is the foundation of data communication on the web. When building web applications, understanding how to handle different HTTP methods is crucial for interacting with resources on the server. The HTTP methods such as GET, POST, PUT, and DELETE are used to perform various actions on resources. In this post, we will explore how to handle these methods in a Node.js HTTP server, and how to differentiate between requests based on their method and URL. We will break down each HTTP method’s role, how they are typically used, and how you can manage them using Node.js’s built-in HTTP module.

By the end of this guide, you will have a solid understanding of how to work with these methods to build a RESTful API or handle requests effectively in your Node.js applications.

---

Table of Contents

1. Introduction to HTTP Methods
2. Understanding the GET Method
   • What is GET?
   • Handling GET Requests in Node.js
   • Common Use Cases for GET Requests
3. Understanding the POST Method
   • What is POST?
   • Handling POST Requests in Node.js
   • Common Use Cases for POST Requests
4. Understanding the PUT Method
   • What is PUT?
   • Handling PUT Requests in Node.js
   • Common Use Cases for PUT Requests
5. Understanding the DELETE Method
   • What is DELETE?
   • Handling DELETE Requests in Node.js
   • Common Use Cases for DELETE Requests
6. Using url and method to Differentiate Requests
7. Building a Simple REST API with Node.js
8. Conclusion

---

1. Introduction to HTTP Methods

HTTP methods are used to specify the type of action you want to perform on a resource. In the context of web development, a “resource” can be any data that the server exposes, such as user information, blog posts, products, etc. The four most commonly used HTTP methods are GET, POST, PUT, and DELETE. These are the foundation of most RESTful web services, and understanding how to handle them correctly is essential for building scalable web applications.

• GET is used to retrieve data from the server.
• POST is used to send data to the server, typically to create a new resource.
• PUT is used to update an existing resource.
• DELETE is used to remove a resource.

Each of these methods plays a specific role in managing resources on the server. In this post, we will discuss how to handle these HTTP methods in your Node.js server, specifically using the built-in http module.

---

2. Understanding the GET Method

2.1 What is GET?

The GET method is used to request data from a specified resource. It is one of the most commonly used HTTP methods. When a client (e.g., a browser or API consumer) sends a GET request to the server, it asks the server to return a resource, such as a webpage, an image, or data from a database.

GET requests are idempotent, meaning that making the same GET request multiple times will produce the same result and does not alter the resource.

2.2 Handling GET Requests in Node.js

Handling GET requests in Node.js involves listening for requests on a specific URL and method, and then responding with the appropriate data. Here’s a simple example of handling a GET request in a Node.js HTTP server:

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.method === 'GET' && req.url === '/hello') {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello, world!');
  } else {
res.statusCode = 404;
res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Server running at http://localhost:3000/');
});

In this example:

• The server listens for GET requests on the /hello endpoint.
• When the client sends a GET request to /hello, the server responds with a “Hello, world!” message.
• If the requested URL is not /hello, the server responds with a 404 error.

2.3 Common Use Cases for GET Requests

• Retrieving data: GET requests are primarily used to retrieve data from the server. For example, in a REST API, you might use GET to fetch user details, a list of products, or blog posts.
• Displaying web pages: Web browsers often send GET requests to load HTML pages.
• Fetching static assets: When a user visits a webpage, the browser sends GET requests to fetch images, stylesheets, and JavaScript files.

---

3. Understanding the POST Method

3.1 What is POST?

The POST method is used to send data to the server, often to create a new resource. When a client sends a POST request, it typically includes data in the request body. This data could be in the form of JSON, form data, or other formats, and the server processes the data to create a new resource or perform an action.

Unlike GET requests, POST requests are not idempotent, meaning that sending the same POST request multiple times can result in different outcomes (e.g., multiple records being created).

3.2 Handling POST Requests in Node.js

To handle POST requests in Node.js, you need to parse the request body, as POST data is usually sent in the body of the request. Here’s an example of handling a POST request:

const http = require('http');
const { parse } = require('querystring');

const server = http.createServer((req, res) => {
  if (req.method === 'POST' && req.url === '/submit') {
let body = '';

req.on('data', chunk => {
  body += chunk;
});
req.on('end', () => {
  const data = parse(body);
  res.statusCode = 200;
  res.setHeader('Content-Type', 'application/json');
  res.end(JSON.stringify({ message: 'Data received', data }));
});
  } else {
res.statusCode = 404;
res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Server running at http://localhost:3000/');
});

In this example:

• The server listens for POST requests on the /submit endpoint.
• The request body is read and parsed using the querystring module.
• The server responds with a JSON object containing the received data.

3.3 Common Use Cases for POST Requests

• Creating resources: POST is often used in RESTful APIs to create new resources, such as adding a new user or creating a new blog post.
• Submitting forms: POST is used when submitting data through forms on web pages, such as user registration or login forms.
• Sending data to the server: Any time you need to send complex data, such as JSON objects or files, to the server, you typically use POST.

---

4. Understanding the PUT Method

4.1 What is PUT?

The PUT method is used to update an existing resource on the server. PUT requests are idempotent, meaning that making the same PUT request multiple times will not result in different outcomes. A PUT request should update the entire resource, replacing it with the new data provided in the request body.

4.2 Handling PUT Requests in Node.js

Here’s an example of handling a PUT request in a Node.js server:

const http = require('http');
const { parse } = require('querystring');

const server = http.createServer((req, res) => {
  if (req.method === 'PUT' && req.url === '/update') {
let body = '';

req.on('data', chunk => {
  body += chunk;
});
req.on('end', () => {
  const data = parse(body);
  // In a real-world app, you'd update the resource in the database here
  res.statusCode = 200;
  res.setHeader('Content-Type', 'application/json');
  res.end(JSON.stringify({ message: 'Resource updated', data }));
});
  } else {
res.statusCode = 404;
res.end('Not Found');
  }
});

server.listen(3000, () => {
  console.log('Server running at http://localhost:3000/');
});

In this example:

• The server listens for PUT requests on the /update endpoint.
• The server processes the data sent in the PUT request and simulates updating the resource.

4.3 Common Use Cases for PUT Requests

• Updating resources: PUT is used to update existing resources. For example, updating a user’s profile information, modifying a blog post, or changing the status of an order.
• Full replacement of a resource: In contrast to PATCH, which is used for partial updates, PUT replaces the entire resource with new data.

---

5. Understanding the DELETE Method

5.1 What is DELETE?

The DELETE method is used to remove a resource from the server. When a DELETE request is sent to the server, the server should delete the resource identified by the URL in the request. Like PUT, DELETE is idempotent, meaning that sending the same DELETE request multiple times will have the same result — the resource will be removed (if it exists).

5.2 Handling DELETE Requests in Node.js

Here’s an example of handling DELETE requests:

const http = require('http');

const server =