Express Middleware

Middleware in [Link] is a function that executes during the lifecycle

of a request to the server. It has access to the request (req), response
(res), and the next middleware function in the application’s request-
response cycle. The next middleware function is commonly denoted by a
variable named next.
Express is a combination of routing and middleware web framework that
has minimal functionality of its own: An Express application is essentially
a series of middleware function calls.
A middleware is a function that hooks into the routing process,
performing an arbitrary operation at some point in the chain (depending
on what we want it to do).
Middleware functions can perform the following tasks:
-Execute any code.
-Make changes to the request and the response objects.
-End the request-response cycle.
-Call the next middleware function in the stack.
Middleware functions can be used for various purposes, such as
logging, authentication, authorization, error handling, and more. You can
create custom middleware functions or use third-party middleware
Types of Middleware
1. Application-Level Middleware: Bound to an instance of the Express
application using `[Link]()` or `[Link]()`, where `METHOD` is
an HTTP method. Useful for tasks such as logging, authentication, and
handling common functionality across different routes.
This example shows a middleware function with no mount path. The
function is executed every time the app receives a request.
const express = require('express')
const app = express()
[Link]((req, res, next) => {
[Link]('Time:', [Link]())
next()
})
[Link](3000);

The above middleware is called for every request on the server. So after
every request, we will get the following message in the console.
A new request received at 1467267512545
To restrict it to a specific route (and all its subroutes), provide that route
as the first argument of [Link]().
For Example,
var express = require('express');
var app = express();
//Middleware function to log request protocol
[Link]('/things', function(req, res, next){
[Link]("A request for things received at " + [Link]());
next();
});
// Route handler that sends the response
[Link]('/things', function(req, res){
[Link]('Things');
});
[Link](3000);
Now whenever you request any subroute of '/things', only then it will log
the time

2. Router-Level Middleware: Similar to application-level middleware but

bound to an instance of `[Link]()`. Helps in organizing and
modularizing the middleware functionality within different routes.
[Link]()
Use the [Link] class to create modular, mountable route
handlers. A Router instance is a complete middleware and routing
system; for this reason, it is often referred to as a “mini-app”. With
routers, you can define routes in separate files and then use them as
middleware in your main application.
Using [Link] is a great way to organize and modularize your
routes in larger [Link] applications. Each router can have its own set
of routes and middleware, making your code more maintainable and
readable.

3. Error Handling Middleware: Defined with four arguments (err, req,

res, next). Specifically designed to catch and handle errors that occur
during the requestresponse cycle.
[Link]((err, req, res, next) => {
[Link]([Link])
[Link](500).send('Something broke!')
})
4. Built-in Middleware: [Link] provides some built-in middleware
functions like
- [Link](): Parses incoming requests with JSON payloads.
- [Link](): Parses incoming requests with URLencoded
payloads.
- [Link]() serves static assets such as HTML files, images, and
so on.

5. Third-party Middleware: Numerous third-party middleware packages

are available to integrate into Express applications for added
functionality. Examples include:
CORS: Handling Cross Origin Resource Sharing,
Session: Managing user sessions,
Cookies: Parsing and handling cookies.

Middleware Syntax
[Link]((req, res, next) => {
// Middleware logic
next(); // Pass control to the next middleware
});

Middleware Order
Middleware is executed in the order it’s defined. Always place general
middleware (e.g., logging) before route-specific handlers.
[Link]((req, res, next) => {
[Link]('First Middleware');
next();
});
[Link]('/', (req, res) => {
[Link]('Route handler');
});

Why Use Middleware?

Code Organization: Middleware helps separate different concerns like
authentication, logging, and error handling into distinct modules. This
separation enhances the readability and maintainability of the code
Reusability: Middleware functions can be reused across different routes
and applications, promoting DRY (Don't Repeat Yourself) principles.
Maintainability: Updating specific functionalities becomes easier as
middleware allows you to change one part of the code without affecting
the rest of the application.
Scalability: Middleware enables the efficient handling of common tasks
across various parts of an application, which aids in scaling the
application.

Basic Example:
const express = require('express');
const app = express(); // Middleware function to log request details
function logRequest(req, res, next) {
[Link](`${[Link]} ${[Link]}`);
next(); // Pass control to the next middleware
}
// Applicationlevel middleware
[Link](logRequest); [Link]('/', (req, res) => {
[Link]('Hello, Middleware!');
});
const PORT = [Link] || 3000;
[Link](PORT, () => {
 [Link](`Server is running on port ${PORT}`);
});

Explanation: `logRequest` is a simple middleware function that logs the

HTTP method and URL of each incoming request. By using
`[Link](logRequest)`, this middleware is applied to all routes in the
application. The `next()` function passes control to the next middleware
function in the stack, allowing for multiple middleware functions to handle
different aspects of a request.
Conclusion: Middleware is a cornerstone of [Link] applications
and, by extension, MERN stack development. It empowers developers to
write clean, modular, and efficient code. By mastering middleware,
developers can significantly enhance the performance and
maintainability of their web applications. Middleware is a powerful
feature in [Link] that helps in modularizing code and managing
functionality like authentication, logging, validation, error handling.

Order of Middleware Calls

One of the most important things about middleware in Express is the
order in which they are written/included in your file; the order in which
they are executed, given that the route matches also needs to be
considered.
For example, in the following code snippet, the first function executes
first, then the route handler and then the end function. This example
summarizes how to use middleware before and after route handler; also
how a route handler can be used as a middleware itself.
var express = require('express');
var app = express();
//First middleware before response is sent
[Link](function(req, res, next){
[Link]("Start");
next();
});
//Route handler
[Link]('/', function(req, res, next){
[Link]("Middle");
next();
});
[Link]('/', function(req, res){
[Link]('End');
});
[Link](3000);
When we visit '/' after running this code, we receive the response as
Middle and
console output :
Start
End

Routing
Routing refers to how an application’s endpoints (URIs) respond to client
requests. Define routing using methods of the Express app object that
correspond to HTTP methods; for example, [Link]() to handle GET
requests and [Link] to handle POST requests. You can also use
[Link]() to handle all HTTP methods and [Link]() to specify
middleware as the callback [Link] routing methods specify a
callback function (sometimes called “handler functions”) called when the
application receives a request to the specified route
(endpoint) and HTTP method. In other words, the application “listens” for
requests that match the specified route(s) and method(s), and when it
detects a match, it calls the specified callback function.
In fact, the routing methods can have more than one callback function as
arguments. With multiple callback functions, it is important to provide
next as an argument to the callback function and then call next() within
the body of the function to hand off control to the next callback.
Route definition takes the following structure:
[Link](PATH, HANDLER)
Where:
app is an instance of express.
METHOD is an HTTP request method, in lowercase.
PATH is a path on the server.
HANDLER is the function executed when the route is matched.
The following code is an example of a very basic route.
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the
homepage
[Link]('/', (req, res) => {
[Link]('hello world')
})

Route methods
A route method is derived from one of the HTTP methods, and is
attached to an instance of the express class.
The following code is an example of routes that are defined for the GET
and the POST methods to the root of the app.
// GET method route
[Link]('/', (req, res) => {
[Link]('GET request to the homepage')
})
// POST method route
[Link]('/', (req, res) => {
[Link]('POST request to the homepage')
})
Respond to a PUT request to the /user route:
[Link]('/user', (req, res) => {
[Link]('Got a PUT request at /user')
})
Respond to a DELETE request to the /user route:
[Link]('/user', (req, res) => {
[Link]('Got a DELETE request at /user')
})

Express supports methods that correspond to all HTTP request

methods: get, post, and so on. For a full list, see [Link].
There is a special routing method, [Link](), used to load middleware
functions at a path for all HTTP request methods. For example, the
following handler is executed for requests to the route “/secret” whether
using GET, POST, PUT, DELETE, or any other HTTP request method
supported in the http module.
[Link]('/secret', (req, res, next) => {
[Link]('Accessing the secret section ...')
next() // pass control to the next handler
})
Express Route Methods:
HTTP GET Method
The GET method is one of the most common HTTP methods. It is used
to request data from a specified resource. GET requests can retrieve
data, but they should not change any data on the server.
[Link], a popular web application framework for [Link], makes
handling GET requests straightforward and efficient. In Express, the
`[Link]()` method is used to define a route that listens for GET
requests.
When you define a GET route, you specify a path and a callback
function. This callback function takes three arguments: `req`, `res`, and
`next`. Here’s a simple example:

```javascript
const express = require('express');
const app = express();

[Link]('/', (req, res) => {

[Link]('Hello, World!');
});

const PORT = [Link] || 3000;

[Link](PORT, () => {
[Link](`Server is running on port ${PORT}`);
});

```
### Explanation of the Code
- `const express = require('express');` - This line imports the Express
module.
- `const app = express();` - We create an instance of an Express
application.
- `[Link]('/', (req, res) => { [Link]('Hello, World!'); });` - Here, we
define a GET route for the root URL (`/`). When this URL is accessed,
the server responds with 'Hello, World!'.
- `const PORT = [Link] || 3000;` - This sets the port the
server will listen on.
- `[Link](PORT, () => { [Link](Server is running on port
${PORT}); });` - This starts the server and listens for connections on the
specified port.

Why Use GET Routes?

GET routes are essential for retrieving data and displaying web pages.
They are widely used for:
- Fetching data from a database.
- Displaying information to users.
- Navigating through different pages of a website.

Conclusion
Understanding the GET method in [Link] is crucial for any web
developer. It allows you to handle requests efficiently and provide users
with the data they need. I encourage you to experiment with defining
your own GET routes to see the power and simplicity of [Link] in
action.
HTTP POST Method
The POST method is used to send data to the server to create a new
resource. Unlike GET requests, POST requests can include a body,
allowing you to send data such as form submissions.

```javascript
const express = require('express');
const app = express();

// Middleware to parse JSON bodies

[Link]([Link]());

// POST route
[Link]('/submit-form', (req, res) => {
const formData = [Link];
// Process the form data here
[Link]('Form submitted successfully!');
});

// Start the server

const PORT = [Link] || 3000;
[Link](PORT, () => {
[Link](`Server is running on port ${PORT}`);
});
```

How to Test the POST Method

Using Postman or cURL:
Postman:
1. Open Postman and create a new POST request.
2. Set the URL to `[Link]
3. In the Body tab, select raw and JSON format, then add JSON data.
```json
{
"name": "John Doe",
"email": "[Link]@[Link]"
}
```
4. Send the request and observe the response.
HTTP PUT Method
The PUT method is used to update an existing resource on the server. It
is idempotent, meaning that multiple identical requests will have the
same effect as a single request.

```javascript
const express = require('express');
const app = express();

// Middleware to parse JSON bodies

[Link]([Link]());

// PUT route
[Link]('/update-user/:id', (req, res) => {
const userId = [Link];
const updatedData = [Link];
// Update user data here
[Link](`User ${userId} updated successfully!`);
});

// Start the server

const PORT = [Link] || 3000;
[Link](PORT, () => {
[Link](`Server is running on port ${PORT}`);
});
```
How to Test the PUT Method
Using Postman or cURL:

Postman:
1. Open Postman and create a new PUT request.
2. Set the URL to `[Link]
3. In the Body tab, select raw and JSON format, then add JSON data.
```json
{
"name": "Jane Doe",
"email": "[Link]@[Link]"
}
```
4. Send the request and observe the response.

Conclusion
The PUT method is crucial for updating existing resources on the server.
It ensures that the specified resource is updated with the provided data,
making it ideal for APIs that require modifications to existing data.
HTTP DELETE Method
The DELETE method is used to delete a resource from the server. It is
used to remove items from a database or files from a server.

```javascript
const express = require('express');
const app = express();

// DELETE route
[Link]('/delete-user/:id', (req, res) => {
const userId = [Link];
// Delete user data here
[Link](`User ${userId} deleted successfully!`);
});

// Start the server

const PORT = [Link] || 3000;
[Link](PORT, () => {
[Link](`Server is running on port ${PORT}`);
});
```

How to Test the DELETE Method

Using Postman or cURL:

Postman:
1. Open Postman and create a new DELETE request.
2. Set the URL to `[Link]
3. Send the request and observe the response.

Conclusion
The DELETE method is essential for removing resources from the
server. It allows for the deletion of specified resources, helping to
maintain clean and updated data on the server.
Route paths
In [Link], route paths define the endpoints for handling HTTP
requests. They can be as simple as a static string or as flexible as a
dynamic pattern with parameters and wildcards.
Route paths, in combination with a request method, define the endpoints
at which requests can be made. Route paths can be strings, string
patterns, or regular expressions.
The characters ?, +, *, and () are subsets of their regular expression
counterparts. The hyphen (-) and the dot (.) are interpreted literally by
string-based paths.
If you need to use the dollar character ($) in a path string, enclose it
escaped within ([ and ]). For example, the path string for requests at
“/data/$book”, would be “/data/([\$])book” .

Defining Routes
Routes in Express are defined using methods corresponding to HTTP
verbs like get, post, put, delete, etc.
Basic Example:
const express = require('express');
const app = express();

[Link]('/', (req, res) => {

[Link]('Hello, World!');
});

[Link](3000, () => [Link]('Server running on port 3000'));

Types of Route Paths

1. Static Routes
 o Match a specific path exactly.
[Link]('/about', (req, res) => {
[Link]('About Page');
});
2. Dynamic Routes
o Use route parameters to handle patterns.
Example with parameters:
[Link]('/user/:id', (req, res) => {
const userId = [Link];
[Link](`User ID: ${userId}`);
});

Multiple Parameters:
[Link]('/user/:id/book/:bookId', (req, res) => {
const { id, bookId } = [Link];
[Link](`User ${id} requested book ${bookId}`);
});
3. Optional Parameters
o Use ? to make parameters optional.
[Link]('/item/:id?', (req, res) => {
if ([Link]) {
[Link](`Item ID: ${[Link]}`);
} else {
[Link]('No item specified');
}
});
4. Wildcard Routes
o Use * as a wildcard to match any path.
[Link]('/wildcard/*', (req, res) => {
[Link]('This route matches anything after /wildcard/');
});
5. Regular Expression Routes
o Use regular expressions for advanced matching.
[Link](/a/, (req, res) => {
[Link]('This route matches paths containing the letter "a"');
});

[Link](/.*fly$/, (req, res) => {

[Link]('This route matches paths ending with "fly"');
});

Route paths as strings

In [Link], route paths with strings are the most common and
straightforward way to define routes. These are static or fixed paths that
match exactly as defined. Here's how to work with route paths as strings:

Examples of Static Route Paths

1. Simple Path
[Link]('/about', (req, res) => {
[Link]('About Page');
});
Access URL: [Link]

2. Multiple Static Routes

You can define multiple routes, each with a different string.
[Link]('/home', (req, res) => {
[Link]('Home Page');
});

[Link]('/contact', (req, res) => {

[Link]('Contact Page');
});

3. Route with Nested Paths

[Link]('/products/electronics', (req, res) => {
[Link]('Electronics Category');
});
Access URL: [Link]

Case Sensitivity
By default, route paths in Express are case-insensitive. To enforce
case sensitivity, use the caseSensitive option when initializing the app.
const express = require('express');
const app = express({ caseSensitive: true });

[Link]('/About', (req, res) => {

[Link]('About Page - Case Sensitive');
});

// /About works, but /about will not match

String Patterns with Special Characters

1. Route with Hyphens
Hyphens in paths are treated literally.
[Link]('/user-profile', (req, res) => {
[Link]('User Profile Page');
});
Access URL: [Link]

2. Route with Periods

Periods in paths are treated literally as well.
[Link]('/[Link]', (req, res) => {
[Link]('File with .txt extension');
});
Access URL: [Link]

3. Route with Query Parameters

Query parameters are not part of the route path. You can access them
via [Link].
[Link]('/search', (req, res) => {
const { q } = [Link];
[Link](`Search Query: ${q}`);
});
Access URL: [Link]

String Patterns in Route Paths

1. Exact Match
o Matches the path exactly.
[Link]('/profile', (req, res) => {
[Link]('Profile Page');
});
Access: /profile

2. Starts With a Specific Path

o Use a wildcard * to allow matching any additional characters.
[Link]('/docs/*', (req, res) => {
[Link]('Documentation Section');
});
Access: /docs/intro, /docs/setup, etc.

3. Combination of Strings
o Define routes with shared segments.
[Link]('/products/clothing', (req, res) => {
[Link]('Clothing Products');
});

[Link]('/products/electronics', (req, res) => {

[Link]('Electronics Products');
});
Each route is matched independently.

Middleware for String Routes

Middleware can process requests to specific string paths.
[Link]('/admin', (req, res, next) => {
[Link]('Admin middleware executed');
next();
});
[Link]('/admin', (req, res) => {
[Link]('Admin Panel');
});

Wildcards with String Routes

You can define catch-all routes for a group of paths using a wildcard *.
[Link]('/blog/*', (req, res) => {
[Link]('Blog section with wildcard');
});
path Pattern Matches

/about /about

/products /products

/products/laptops /products/laptops

/help/* /help/faq, /help/support

/user-profile /user-profile
String routes are the simplest way to define paths in Express. Use them
for fixed, well-defined URLs.

Route Paths with Regular Expressions

In [Link], you can use regular expressions in route paths to
define more flexible and powerful matching patterns. This is particularly
useful when you need to handle dynamic URLs with advanced
conditions.

Syntax
To use a regular expression as a route path, pass it as the first argument
in the route definition:
[Link](/pattern/, (req, res) => {
[Link]('Matched a route with a regex pattern!');
});

Examples of Regular Expression Routes

1. Match Specific Words

Match a route that contains a specific word.
[Link](/hello/, (req, res) => {
[Link]('Route contains "hello"');
});
Matches:
 /hello
 /sayhello
 /hello-world

2. Match Paths Ending with a Specific Word

Use $ to indicate the end of the string.
[Link](/world$/, (req, res) => {
[Link]('Route ends with "world"');
});
Matches:
 /world
 /say/world
Does NOT Match:
  /worldwide

3. Match Any Path with Digits

Match paths that include numbers using \d.
[Link](/\d+/, (req, res) => {
[Link]('Route contains numbers');
});
Matches:
 /123
 /product/456
Does NOT Match:
 /abc
 /test

4. Match Multiple Variations

Use | to match multiple variations.
[Link](/(cat|dog)/, (req, res) => {
[Link]('Matched "cat" or "dog"');
});
Matches:
 /cat
 /dog
 /my-cat
 /mydog
Does NOT Match:
 /bird
5. Match Case-Insensitive Routes
Use the i flag for case-insensitivity.
[Link](/about/i, (req, res) => {
[Link]('Case-insensitive "about" route');
});
Matches:
 /about
 /ABOUT
 /AbOuT

6. Match Paths with Optional Characters

Use ? to make a character optional.
[Link](/colou?r/, (req, res) => {
[Link]('Matched "color" or "colour"');
});
Matches:
 /color
 /colour

7. Match Repeated Characters

Use {} to specify the number of repetitions.
[Link](/a{2,5}/, (req, res) => {
[Link]('Matched "a" repeated 2 to 5 times');
});
Matches:
 /aa
 /aaa
  /aaaaa
Does NOT Match:
 /a
 /aaaaaa

8. Match Wildcards
Use .* to match anything.
[Link](/.*fly$/, (req, res) => {
[Link]('Matched a route ending with "fly"');
});
Matches:
 /butterfly
 /dragonfly

Accessing Parameters with Regular Expressions

You can still use [Link] when using regex routes by combining it
with named parameters.
[Link](/user\/(\d+)/, (req, res) => {
const userId = [Link][0]; // The first match group
[Link](`User ID: ${userId}`);
});
Matches:
 /user/123 → User ID: 123

Practical Examples
Example 1: Validate IDs
Use regex to validate that an ID is numeric.
[Link](/^\/user\/\d+$/, (req, res) => {
[Link]('Valid user ID');
});
Matches:
 /user/123
 /user/456
Does NOT Match:
 /user/abc
 /user/123abc

Example 2: Match Specific File Extensions

Serve specific file types based on extensions.
[Link](/\.html$/, (req, res) => {
[Link]('HTML file requested');
});
Matches:
 /[Link]
 /[Link]

Example 3: Validate Dates

Match and extract dates in a specific format (e.g., YYYY-MM-DD).
[Link](/\/date\/(\d{4})-(\d{2})-(\d{2})/, (req, res) => {
const [year, month, day] = [Link];
[Link](`Year: ${year}, Month: ${month}, Day: ${day}`);
});
Matches:
 /date/2024-11-29 → Year: 2024, Month: 11, Day: 29

Route handlers
We can provide multiple callback functions that behave
like middleware to handle a request. The only exception is that these
callbacks might invoke next('route') to bypass the remaining route
callbacks. We can use this mechanism to impose pre-conditions on a
route, then pass control to subsequent routes if there’s no reason to
proceed with the current route.
Route handlers can be in the form of a function, an array of functions, or
combinations of both, as shown in the following examples.
A single callback function can handle a route. For example:
[Link]('/example/a', (req, res) => {
[Link]('Hello from A!')
})

More than one callback function can handle a route (make sure you
specify the next object). For example:
[Link]('/example/b', (req, res, next) => {
[Link]('the response will be sent by the next function ...')
next()
}, (req, res) => {
[Link]('Hello from B!')
})
An array of callback functions can handle a route. For example:
const cb0 = function (req, res, next) {
[Link]('CB0')
next()
}

const cb1 = function (req, res, next) {

[Link]('CB1')
next()
}

const cb2 = function (req, res) {

[Link]('Hello from C!')
}

[Link]('/example/c', [cb0, cb1, cb2])

A combination of independent functions and arrays of functions

can handle a route. For example:
const cb0 = function (req, res, next) {
[Link]('CB0')
next()
}

const cb1 = function (req, res, next) {

[Link]('CB1')
next()
}
[Link]('/example/d', [cb0, cb1], (req, res, next) => {
[Link]('the response will be sent by the next function ...')
next()
}, (req, res) => {
[Link]('Hello from D!') })

Response methods

The methods on the response object (res) in the following table can
send a response to the client, and terminate the request-response cycle.
If none of these methods are called from a route handler, the client
request will be left hanging.
[Link]() :
The [Link]() function transfers the file at the path as an
‘attachment’. Typically, browsers will prompt the user to download.
Syntax:
[Link](path [, filename] [, options] [, fn])
Parameters: The filename is the name of the file which is to be
downloaded as an attachment and fn is a callback function.
Return Value: It does not return anything.
The [Link]() function in [Link] allows you to download files
from the server
const express = require('express');
const app = express();
const PORT = 3000;

[Link]('/', function (req, res) {

[Link]([Link]);
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});

[Link]() :
The [Link]() function concludes the response process and is derived
from the [Link]’s [Link]() method in the Node
core. It is employed to promptly conclude the response without including
any data.
Syntax:
[Link]([data] [, encoding])
Parameters: The default encoding is ‘utf8‘ and the data parameter is the
data with which the user wants to end the response.
Return Value: It returns an Object.
[Link]() function in [Link] is basically used to end a response
process.
const express = require('express');
const app = express();
const PORT = 3000;

// With middleware
[Link]('/user',
function (req, res, next) {
[Link]("/user called")
[Link]();
})

[Link]('/user',
function (req, res) {
[Link]("User Page")
[Link]();
});

[Link](PORT,
function (err) {
if (err) [Link](err);
[Link]("Server listening on PORT", PORT); });
[Link]() :
The [Link]() function sends a JSON response. This method sends a
response (with the correct content-type) that is the parameter converted
to a JSON string using the [Link]() method.
Syntax:
[Link]( [body] )
Parameters: The body parameter is the body that is to be sent in the
response.
Return Value: It returns an Object.
const express = require('express');
const app = express();
const PORT = 3000;

// Without middleware
[Link]('/', function (req, res) {
[Link]({ username: 'A32' });
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});

[Link]() :
The [Link]() function redirects to the URL derived from the
specified path, with specified status, an integer (positive) which
corresponds to an HTTP status code. The default status is “302 Found”.
Syntax
[Link]([status] path)
Parameter: This function accepts two parameters as mentioned above
and described below:
 status: This parameter holds the HTTP status code
 path: This parameter describes the path.
Return Value: It returns an Object.
[Link]('/google', (req, res) => {
[Link]('[Link]
});

const express = require('express');

const app = express();
const PORT = 3000;

// Without middleware
[Link]('/', function (req, res) {
[Link]('/user');
});

[Link]('/user', function (req, res) {

[Link]("Redirected to User Page");
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});
[Link]() :
The [Link]() function in Express is used to render a view and sends
the rendered HTML string to the client.
Syntax:
[Link](view [, locals] [, callback])
Parameters: This function accepts two parameters as mentioned above
and described below:
 Locals: It is an object whose properties define local variables for
the view.
 Callback It is a callback function.
Returns: It returns an Object.

const express = require('express');

const app = express();
const PORT = 3000;

// View engine setup

[Link]('view engine', 'ejs');

// Without middleware
[Link]('/user', function (req, res) {

// Rendering [Link] page

[Link]('home');
})

[Link](PORT, function (err) {

if (err) [Link](err);
 [Link]("Server listening on PORT", PORT);
});

<html>
<head>
<title>[Link]() Demo</title>
</head>
<body>
<h2>Render function working</h2>
</body>
</html>

[Link]() :
The [Link] function is used to send a response in form of various
types of data, such as strings, objects, arrays, or buffers, and
automatically sets the appropriate Content-Type header based on the
data [Link] [Link]() function sends the HTTP response. The body
parameter can be a String or a Buffer object or an object or an Array.
Syntax:
[Link]( [body] )
Parameter: This function accepts a single parameter body that
describes the body to be sent in the response. e.g., string, array, object
etc.
Returns: It returns an Object.

const express = require('express');

const app = express();
const PORT = 3000;
// Without middleware
[Link]('/', function (req, res) {
[Link]({ title: 'Unit 4' });
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});

[Link]() :
The [Link]() function transfers the file at the given path and it sets
the Content-Type response HTTP header field based on the filename
extension.
Syntax:
[Link](path [, options] [, fn])
Parameter: The path parameter describes the path and the options
parameter contains various properties like maxAge, root, etc and fn is
the callback function.
Returns: It returns an Object.
const express = require('express');
const app = express();
const path = require('path');
const PORT = 3000;

// Without middleware
[Link]('/', function (req, res) {
const options = {
root: [Link](__dirname)
 };

const fileName = '[Link]';

[Link](fileName, options, function (err) {
if (err) {
[Link]('Error sending file:', err);
} else {
[Link]('Sent:', fileName);
}
});
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});

[Link]() :
The [Link]() function is used to set the response HTTP status
code to statusCode and send its string representation as the response
body.
Syntax:
[Link]( statusCode )
Parameter: The statusCode parameter describes the HTTP status code.
Returns: It returns an Object.
const express = require('express');
const app = express();
const PORT = 3000;
// Without middleware
[Link]('/', function (req, res) {

// Equivalent to [Link](200).send('OK')
[Link](200);
});

[Link](PORT, function (err) {

if (err) [Link](err);
[Link]("Server listening on PORT", PORT);
});