Routes and Route Handlers
Routing is a fundamental aspect of Express.js, enabling the application to respond to client requests at specific endpoints (URIs) and defining how the application handles these requests. This chapter will cover routes and route handlers in Express.js from basic to advanced concepts, providing comprehensive explanations and examples.
Introduction to Routes
Routes in Express.js are essentially the URL patterns that define how the application responds to client requests. A route is defined by a path and one or more HTTP methods.
Basic Routing
Basic routing involves defining endpoints and specifying how the application should respond to client requests.
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Home Page');
});
app.get('/about', (req, res) => {
res.send('About Page');
});
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});
Explanation:
app.get('/', (req, res) => {...}): Defines a GET route for the root URL (/).app.get('/about', (req, res) => {...}): Defines a GET route for the/aboutURL.res.send(...): Sends a response to the client.
Output:
- Navigating to
http://localhost:3000displays “Home Page”. - Navigating to
http://localhost:3000/aboutdisplays “About Page”.
Route Parameters
Route parameters are used to capture values specified at certain positions in the URL.
app.get('/users/:id', (req, res) => {
res.send(`User ID: ${req.params.id}`);
});
Explanation:
:id: A route parameter that captures the value in the URL.req.params.id: Accesses the captured value.
Output: Navigating to http://localhost:3000/users/123 displays “User ID: 123”.
Query Strings
Query strings are used to pass additional information in the URL in the form of key-value pairs.
app.get('/search', (req, res) => {
res.send(`Search Query: ${req.query.q}`);
});
Explanation:
req.query.q: Accesses the query string parameterq.
Output: Navigating to http://localhost:3000/search?q=express displays “Search Query: express”.
Handling Different HTTP Methods
Express.js supports various HTTP methods, allowing you to define routes for GET, POST, PUT, DELETE, and more.
app.post('/submit', (req, res) => {
res.send('Form Submitted');
});
app.put('/update/:id', (req, res) => {
res.send(`Updated User ID: ${req.params.id}`);
});
app.delete('/delete/:id', (req, res) => {
res.send(`Deleted User ID: ${req.params.id}`);
});
Explanation:
app.post(...): Defines a POST route.app.put(...): Defines a PUT route.app.delete(...): Defines a DELETE route.
Output:
- Sending a POST request to
/submitdisplays “Form Submitted”. - Sending a PUT request to
/update/123displays “Updated User ID: 123”. - Sending a DELETE request to
/delete/123displays “Deleted User ID: 123”.
Route Handlers
Route handlers are functions that handle the HTTP requests. You can define multiple route handlers for a single route.
const logRequest = (req, res, next) => {
console.log(`${req.method} request for ${req.url}`);
next();
};
const sendResponse = (req, res) => {
res.send('Request logged and response sent');
};
app.get('/log', logRequest, sendResponse);
Explanation:
logRequest: A middleware function that logs the request.sendResponse: A function that sends the response.app.get('/log', logRequest, sendResponse): Uses both functions as route handlers.
Output: Navigating to http://localhost:3000/log logs the request and displays “Request logged and response sent”.
Middleware and Routes
Middleware functions can be used in routes to perform tasks such as authentication, validation, and logging.
const authenticate = (req, res, next) => {
if (req.query.auth === 'true') {
next();
} else {
res.send('Authentication required');
}
};
app.get('/protected', authenticate, (req, res) => {
res.send('Protected Resource');
});
Explanation:
authenticate: A middleware function that checks for an authentication query parameter.app.get('/protected', authenticate, (req, res) => {...}): Uses theauthenticatemiddleware.
Output:
- Navigating to
http://localhost:3000/protected?auth=truedisplays “Protected Resource”. - Navigating to
http://localhost:3000/protecteddisplays “Authentication required”.
Express Router
The Express Router allows you to create modular, mountable route handlers.
userRoutes.js:
const express = require('express');
const router = express.Router();
router.get('/', (req, res) => {
res.send('User List');
});
router.get('/:id', (req, res) => {
res.send(`User ID: ${req.params.id}`);
});
module.exports = router;
app.js:
const express = require('express');
const app = express();
const userRoutes = require('./userRoutes');
app.use('/users', userRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});
Explanation:
userRoutes.js: Defines a router with routes for/usersand/users/:id.app.use('/users', userRoutes): Mounts theuserRoutesrouter on the/userspath.
Output:
- Navigating to
http://localhost:3000/usersdisplays “User List”. - Navigating to
http://localhost:3000/users/123displays “User ID: 123”.
Nested and Modular Routing
Nested and modular routing help organize routes in a scalable way, especially for large applications.
adminRoutes.js:
const express = require('express');
const router = express.Router();
router.get('/', (req, res) => {
res.send('Admin Dashboard');
});
router.get('/users', (req, res) => {
res.send('Admin User Management');
});
module.exports = router;
app.js:
const express = require('express');
const app = express();
const adminRoutes = require('./adminRoutes');
app.use('/admin', adminRoutes);
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});
Explanation:
adminRoutes.js: Defines routes under the/adminpath.app.use('/admin', adminRoutes): Mounts theadminRoutesrouter on the/adminpath.
Output:
- Navigating to
http://localhost:3000/admindisplays “Admin Dashboard”. - Navigating to
http://localhost:3000/admin/usersdisplays “Admin User Management”.
Error Handling in Routes
Error handling middleware can be used to catch and handle errors in your application.
app.get('/error', (req, res, next) => {
const err = new Error('Something went wrong!');
next(err);
});
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Internal Server Error');
});
Explanation:
app.get('/error', (req, res, next) => {...}): Simulates an error and passes it to the next middleware.app.use((err, req, res, next) => {...}): Error handling middleware that logs the error and sends a response.
Output: Navigating to http://localhost:3000/error logs the error and displays “Internal Server Error”.
Understanding routes and route handlers is crucial for building efficient and maintainable Express.js applications. This chapter covered basic routing, route parameters, query strings, handling different HTTP methods, using middleware, modular routing with the Express Router, and error handling.Happy coding !❤️