Express - A Web Framework for Node.js
Express is a fast, unopinionated, and minimalist web framework for Node.js.
It provides robust tools for creating server-side applications and APIs, handling HTTP requests and responses, and managing various other aspects of web application development.
Why Use Express?
Minimalist: Express is lightweight and does not come with unnecessary features, allowing developers to build applications with a small footprint.
Flexible: It provides a thin layer of fundamental web application features, without obscuring Node.js features.
Extensible: Numerous middleware modules are available to extend its functionality.
Performance: Built on top of the asynchronous, non-blocking Node.js runtime, Express can handle a large number of simultaneous connections efficiently.
Setting Up an Express Application
Initialize a Node.js Project:
npm init -yInstall Express:
npm install expressBasic Application Structure:
const express = require('express');
const app = express();
const port = 3000;
app.get('/', (req, res) => {
res.send('Hello World!');
});
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`);
});Middleware in Express
Middleware functions are functions that have access to
the request object (req)
the response object (res)
the next middleware function in the application’s request-response cycle.
Middleware can:
Execute any code.
Make changes to the request and response objects.
End the request-response cycle.
Call the next middleware function.
Example of Middleware:
const express = require('express');
const app = express();
const port = 3000;
// Middleware function to log request details
app.use((req, res, next) => {
console.log(`Request Method: ${req.method}, Request URL: ${req.url}`);
next();
});
app.get('/', (req, res) => {
res.send('Hello World!');
});
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`);
});
Routing in Express
Routing refers to how an application’s endpoints (URIs) respond to client requests.
Express provides a simple and flexible way to define routes.
Basic Routing Example:
app.get('/', (req, res) => {
res.send('Home Page');
});
app.get('/about', (req, res) => {
res.send('About Page');
});Route Parameters:
Route parameters are named URL segments that capture the values specified at their position in the URL.
app.get('/users/:userId/books/:bookId', (req, res) => {
res.send(req.params);
});Handling Different HTTP Methods
Express can handle various HTTP methods such as GET, POST, PUT, DELETE, etc.
Example:
app.post('/user', (req, res) => {
res.send('Got a POST request');
});
app.put('/user', (req, res) => {
res.send('Got a PUT request at /user');
});
app.delete('/user', (req, res) => {
res.send('Got a DELETE request at /user');
});Serving Static Files
Express provides a built-in middleware to serve static files such as images, CSS files, and JavaScript files.
Example:
app.use(express.static('public'));This will serve all files in the public directory at the root URL.
Error Handling
Error handling middleware functions have four arguments: (err, req, res, next).
Example:
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Something broke!');
});Working with JSON and URL-encoded Data
Express has built-in middleware to handle JSON and URL-encoded data.
Example:
app.use(express.json()); // for parsing application/json
app.use(express.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencodedExample Application with Express
Here's a more complete example showcasing an Express application with multiple routes, middleware, error handling, and serving static files:
const express = require('express');
const path = require('path');
const app = express();
const port = 3000;
// Middleware to log request details
app.use((req, res, next) => {
console.log(`${req.method} request for '${req.url}'`);
next();
});
// Middleware to serve static files
app.use(express.static(path.join(__dirname, 'public')));
// Body parser middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
// Basic route
app.get('/', (req, res) => {
res.send('Welcome to the Home Page!');
});
// Route with parameters
app.get('/users/:userId', (req, res) => {
res.send(`User ID: ${req.params.userId}`);
});
// Handling POST request
app.post('/submit', (req, res) => {
res.send(`Form submitted! Name: ${req.body.name}`);
});
// Error handling middleware
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Something broke!');
});
app.listen(port, () => {
console.log(`Server running at http://localhost:${port}/`);
});
In this example: Middleware is used to log request details and serve static files from the public directory. The body-parser middleware is used to parse JSON and URL-encoded data. Routes are defined to handle GET and POST requests. An error-handling middleware is included to handle any errors that occur during request processing. This example showcases how Express simplifies the development of robust web applications with a clean and modular structure.
Last updated