- Middleware in Express.js refers to functions that have access to the request, response, and the next middleware function in the application's request-response cycle. These functions can modify the request and response objects, end the request-response cycle, or call the next middleware function in the stack.
- Middleware functions play a crucial role in Express.js applications, allowing developers to perform various tasks, such as logging, authentication, error handling, and more.
const express = require('express');
const app = express();
// Middleware function
const myMiddleware = (req, res, next) => {
console.log('Middleware executed!');
next(); // Call the next middleware in the stack
};
// Use the middleware for all routes
app.use(myMiddleware);
// Route handler
app.get('/', (req, res) => {
res.send('Hello, World!');
});
const PORT = 3000;
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
- In this example, `myMiddleware` is a basic middleware function that logs a message. It is used for all routes using `app.use(myMiddleware)`.
- Application-level Middleware: Middleware that is bound to the application instance. It executes for every incoming request.
app.use(express.json()); // Parses incoming JSON requests
app.use(express.urlencoded({ extended: true })); // Parses incoming URL-encoded requests
app.use(myMiddleware); // Custom middleware
- Router-level Middleware: Middleware that is bound to a specific router. It is similar to application-level middleware but is applied to a specific router instance.
const router = express.Router();
router.use(myMiddleware);
router.get('/', (req, res) => {
res.send('Router-level Middleware Example');
});
app.use('/example', router); // Mount the router at a specific path
- Error Handling Middleware: Middleware that takes four arguments (err, req, res, next) and is used to handle errors.
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Something went wrong!');
});
- Built-in Middleware: Express.js includes some built-in middleware functions for common tasks, such as serving static files.
app.use(express.static('public')); // Serve static files from the 'public' directory
- Third-party Middleware: Middleware provided by third-party packages. Examples include body parsers, authentication middleware, etc.
npm install helmet
const helmet = require('helmet');
app.use(helmet()); // Third-party security middleware
- Custom Middleware: Developers can create custom middleware functions to perform specific tasks. These functions take three parameters: req, res, and next.
const myMiddleware = (req, res, next) => {
console.log('Custom Middleware');
next();
};
app.use(myMiddleware);
- Error Handling Middleware: Middleware that is specifically designed to handle errors in the application.
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Internal Server Error');
});
- Middleware Execution Order: The order in which middleware is defined matters. Middleware is executed in the order it is added using `app.use()` or `router.use()`.
app.use(middleware1);
app.use(middleware2);
app.use(middleware3);
- In the above example, `middleware1` will be executed first, followed by `middleware2`, and then `middleware3`.
- Middleware functions are crucial in Express.js for handling various tasks during the request-response cycle.
- Application-level middleware is bound to the application instance, while router-level middleware is bound to a specific router.
- Error handling middleware is used to catch and handle errors in the application.
- Express.js provides built-in middleware and allows developers to use third-party and custom middleware.
- The order in which middleware is defined determines the order of execution during the request-response cycle.
No comments:
Post a Comment