HTTP Methods

RESTful APIs use standard HTTP methods (GET, POST, PUT, PATCH, DELETE) to perform actions on resources:

  • GET: Retrieves a representation of a resource (e.g., get user information).
  • POST: Creates a new resource (e.g., add a new product to a shopping cart).
  • PUT: Updates an existing resource (e.g., modify user profile information).
  • PATCH: Makes partial updates to a resource (e.g., change a user’s password).
  • DELETE: Deletes a resource (e.g., remove an item from a list).
JavaScript
const express = require('express');
const app = express();
const port = 3000;

// Middleware to parse JSON bodies
app.use(express.json());

// GET: Retrieves a representation of a resource from the server
app.get('/resource', (req, res) => {
    // Here you would retrieve and return the resource
    res.send('GET request to /resource');
});

// POST: Sending resource to the server
app.post('/resource', (req, res) => {
    // Here you would process the resource sent in the request body
    console.log('Received resource:', req.body);
    res.send('POST request to /resource');
});

// PUT: To replace or update an entire resource or replace it with a new representation
app.put('/resource/:id', (req, res) => {
    // Here you would update the resource with the specified ID
    console.log('Updated resource with ID', req.params.id);
    res.send('PUT request to /resource/:id');
});

// PATCH: To make partial updates to a resource
app.patch('/resource/:id', (req, res) => {
    // Here you would apply partial updates to the resource with the specified ID
    console.log('Patched resource with ID', req.params.id);
    res.send('PATCH request to /resource/:id');
});

// DELETE: Deletes a resource
app.delete('/resource/:id', (req, res) => {
    // Here you would delete the resource with the specified ID
    console.log('Deleted resource with ID', req.params.id);
    res.send('DELETE request to /resource/:id');
});

// Start the server
app.listen(port, () => {
    console.log(`Server running on http://localhost:${port}`);
});

Output:

GET /resource: Retrieves a representation of a resource.
POST /resource: Sends a resource to the server.
PUT /resource/:id: Replaces or updates an entire resource.
PATCH /resource/:id: Makes partial updates to a resource.
DELETE /resource/:id: Deletes a resource.

What makes an API RESTful?

An API (Application Programming Interface) acts as a messenger between different software applications. It defines a set of rules, protocols, and specifications for how applications request data, exchange information, and receive responses.

Table of Content

  • Introduction to REST API
  • HTTP Methods
  • Representation
  • Clinet-Server
  • Stateless Communication
  • Resource-Based
  • Self-Descriptive Messages
  • Hypermedia (HATEOAS – Hypermedia as the Engine of Application State)
  • Best Practices for Designing Robust and User-Friendly RESTful APIs

Similar Reads

Introduction to REST API

A RESTful API (Representational State Transfer API) is an architectural style for designing networked applications. It is based on a set of principles that define how resources are identified and addressed, and how interactions occur between clients and servers over HTTP....

HTTP Methods

RESTful APIs use standard HTTP methods (GET, POST, PUT, PATCH, DELETE) to perform actions on resources:...

Representation

Resources are represented in a specific standard data format like JSON(Javascript Object Notation) and that is sent in response to the client.This is the representation part of the representational state transfer....

Clinet-Server

Clients and servers in RESTful APIs are completely separate.They are not on the same system or in the same file and they’re able to message each other over a network in order to make requests and get back responses.This part of the RESTful API architecture allows each side to be able to scale independently each other and they can evolve and be completely built separately by different people. RESTful API allows the whole system to scale very easily....

Stateless Communication

The server shouldn’t be storing any sort of client side,state or client data between the requests,this means that each single request can be complete and each single response is also complete without need to know what happened previously. This allows better scalability of the API and it simplifies the server side implementation....

Resource-Based

It is an API that is centered around resources and uses an unique resource identifier(URI), also known as a Unique resource locator(URL) identifies that resources in the API....

Self-Descriptive Messages

Responses often include metadata (status codes, error messages) to guide clients and improve debugging.Imagine a restaurant waiter informing you if your order went through successfully or if there are any issues (e.g., item unavailable)....

Hypermedia (HATEOAS – Hypermedia as the Engine of Application State)

Ideal RESTful APIs provide links within responses to expose available related resources and actions. This promotes discoverability and reduces the need for hardcoded URLs.Think of a restaurant menu recommending side dishes to complement your main course. The menu itself guides you towards other relevant resources (dishes)....

Best Practices for Designing Robust and User-Friendly RESTful APIs

Creating well-structured RESTful APIs is essential for seamless communication between applications and efficient data exchange. Here are some key best practices to follow:...

Contact Us