Skip to content
BackendExpressJsNodeJs

3. Express Middleware समझे – Application, Router, Error Middleware

April 22, 2026 20 min read

नमस्ते दोस्तों! 🙏
स्वागत है The Easy Master पर!

क्या तुमने कभी सोचा है – Express.js middleware kya hota hai? app.use() क्यों use karte hain? Error handling kaise kaam karta hai?

Middleware Express.js का heart है। यह request और response के बीच में execute होने वाले functions हैं।

Express middleware Hindi में समझना बहुत जरूरी है क्योंकि:

  • Har Express app middleware use karta hai
  • Authentication, logging, validation – सब middleware से होता है
  • Interview mein pakka middleware questions puche jayenge
  • Custom middleware likhna sikho ge

Aaj kya seekhoge?

TopicKya Seekhega?
Middleware Kya Hai?Concept aur flow
Application-level Middlewareapp.use()
Router-level Middlewarerouter.use()
Built-in Middlewareexpress.json, express.static
Third-party Middlewaremorgan, cors, helmet
Error-handling Middleware4 parameters
Custom MiddlewareApna middleware likhna

Kya tumhe pata hai?
Error-handling middleware mein 4 parameters (err, req, res, next) hote hain – Express automatically pehchan leta hai!

तो चलिए शुरू करते हैं – Express middleware Hindi सीखने का सफर! 🚀

Table of Contents

1. Middleware Kya Hai? – Introduction

Middleware ek function hai jo request (req) और response (res) objects तक access rakhta hai, aur next() function call karta hai.

Simple Analogy:

Express Middleware

Basic Middleware Structure:

Code
// Middleware function
function myMiddleware(req, res, next) {
  console.log('Middleware executed!');
  
  // Modify request
  req.customProperty = 'Hello from middleware';
  
  // Call next middleware
  next();
}

// Apply to all routes
app.use(myMiddleware);

// Apply to specific route
app.get('/special', myMiddleware, (req, res) => {
  res.json({ message: req.customProperty });
});

Express middleware Hindi में हम सभी types cover करेंगे।

2. Middleware Flow – कैसे काम करता है?

Visual Flow:

Middleware Flow

Simple Example:

Code
const express = require('express');
const app = express();

// Middleware 1: Logger
app.use((req, res, next) => {
  console.log(`[1] ${req.method} ${req.url}`);
  next();
});

// Middleware 2: Add timestamp
app.use((req, res, next) => {
  req.requestTime = new Date().toISOString();
  console.log(`[2] Timestamp added: ${req.requestTime}`);
  next();
});

// Middleware 3: Authentication check
app.use((req, res, next) => {
  const token = req.headers.authorization;
  if (!token) {
    console.log('[3] No token found');
  } else {
    console.log('[3] Token present');
  }
  next();
});

// Route handler
app.get('/', (req, res) => {
  console.log('[ROUTE] Sending response');
  res.json({
    message: 'Hello World!',
    requestTime: req.requestTime
  });
});

app.listen(3000);

Output:

Code
[1] GET /
[2] Timestamp added: 2026-01-01T10:30:00.000Z
[3] No token found
[ROUTE] Sending response

3. Application-level Middleware – app.use()

Application-level middleware app.use() या app.METHOD() से bind hota है।

Types of Application-level Middleware:

Code
const express = require('express');
const app = express();

// 1. No path – runs for every request
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

// 2. With path – runs for specific path
app.use('/api', (req, res, next) => {
  console.log('API request received');
  next();
});

// 3. For specific HTTP method + path
app.get('/api/users', (req, res, next) => {
  console.log('GET /api/users');
  next();
});

// 4. Multiple middleware functions
const middleware1 = (req, res, next) => {
  console.log('Middleware 1');
  next();
};

const middleware2 = (req, res, next) => {
  console.log('Middleware 2');
  next();
};

app.get('/api/data', [middleware1, middleware2], (req, res) => {
  res.json({ message: 'Data' });
});

// 5. Middleware with next('route')
app.get('/api/users/:id', (req, res, next) => {
  if (req.params.id === '0') {
    next('route'); // Skip to next route
  } else {
    next();
  }
}, (req, res) => {
  res.send('Regular user');
});

app.get('/api/users/:id', (req, res) => {
  res.send('Special user (id=0)');
});

Complete Logger Middleware Example:

Code
// logger.js
const fs = require('fs');
const path = require('path');

// Create write stream for logs
const logStream = fs.createWriteStream(
  path.join(__dirname, 'access.log'),
  { flags: 'a' }
);

// Custom logger middleware
function logger(req, res, next) {
  const start = Date.now();
  
  // Log request
  console.log(`📥 ${req.method} ${req.url}`);
  
  // Capture response finish event
  res.on('finish', () => {
    const duration = Date.now() - start;
    const log = `${new Date().toISOString()} | ${req.method} | ${req.url} | ${res.statusCode} | ${duration}ms\n`;
    
    // Write to file
    logStream.write(log);
    
    // Console output
    console.log(`📤 ${req.method} ${req.url} - ${res.statusCode} - ${duration}ms`);
  });
  
  next();
}

module.exports = logger;
JavaScript
// server.js
const express = require('express');
const logger = require('./logger');

const app = express();

// Apply logger to all routes
app.use(logger);

app.get('/', (req, res) => {
  res.send('Home Page');
});

app.get('/api/users', (req, res) => {
  res.json([{ name: 'Rahul' }]);
});

app.listen(3000);

4. Router-level Middleware – router.use()

Router-level middleware express.Router() instance पर काम करता है।

Basic Router Middleware:

Code
// routes/users.js
const express = require('express');
const router = express.Router();

// Middleware specific to this router
router.use((req, res, next) => {
  console.log('Users router middleware');
  console.log('Time:', Date.now());
  next();
});

// Middleware for specific route
router.use('/:id', (req, res, next) => {
  console.log(`User ID: ${req.params.id}`);
  next();
});

// Routes
router.get('/', (req, res) => {
  res.json({ message: 'Get all users' });
});

router.get('/:id', (req, res) => {
  res.json({ message: `Get user ${req.params.id}` });
});

router.post('/', (req, res) => {
  res.json({ message: 'Create user' });
});

module.exports = router;
JavaScript
// server.js
const express = require('express');
const userRoutes = require('./routes/users');

const app = express();

// Apply router-level middleware
app.use('/api/users', userRoutes);

app.listen(3000);

Authentication Middleware for Router:

Code
// middleware/auth.js
function authenticate(req, res, next) {
  const token = req.headers.authorization;
  
  if (!token) {
    return res.status(401).json({ error: 'No token provided' });
  }
  
  if (token !== 'Bearer secret123') {
    return res.status(403).json({ error: 'Invalid token' });
  }
  
  req.user = { id: 1, name: 'Rahul' };
  next();
}

function isAdmin(req, res, next) {
  if (req.user && req.user.name === 'Rahul') {
    next();
  } else {
    res.status(403).json({ error: 'Admin access required' });
  }
}

module.exports = { authenticate, isAdmin };
JavaScript
// routes/admin.js
const express = require('express');
const router = express.Router();
const { authenticate, isAdmin } = require('../middleware/auth');

// Apply auth to all routes in this router
router.use(authenticate);
router.use(isAdmin);

// Now all these routes are protected
router.get('/dashboard', (req, res) => {
  res.json({ message: 'Admin Dashboard' });
});

router.get('/users', (req, res) => {
  res.json({ message: 'All users (admin only)' });
});

router.delete('/users/:id', (req, res) => {
  res.json({ message: `Deleted user ${req.params.id}` });
});

module.exports = router;

5. Built-in Middleware – express.json, express.static

Express.js ke paas 4 built-in middleware hain:

1. express.json() – Parse JSON Body

Code
const express = require('express');
const app = express();

// Parse JSON request body
app.use(express.json());

// With options
app.use(express.json({
  limit: '10mb',           // Max body size
  type: 'application/json', // Content-Type
  reviver: (key, value) => {
    // Custom parsing logic
    return value;
  }
}));

app.post('/api/data', (req, res) => {
  console.log(req.body); // Parsed JSON
  res.json({ received: req.body });
});

2. express.urlencoded() – Parse Form Data

Code
// Parse URL-encoded form data (HTML forms)
app.use(express.urlencoded({ extended: true }));

// extended: true – nested objects support
// extended: false – simple key-value pairs

app.post('/api/contact', (req, res) => {
  console.log(req.body); // { name: 'Rahul', email: 'rahul@example.com' }
  res.json({ message: 'Form received' });
});

3. express.static() – Serve Static Files

Code
// Serve static files from 'public' directory
app.use(express.static('public'));

// With custom path
app.use('/static', express.static('public'));

// Multiple directories
app.use(express.static('public'));
app.use(express.static('uploads'));

// With options
app.use(express.static('public', {
  maxAge: '1d',           // Cache for 1 day
  etag: true,             // Enable ETag
  lastModified: true,     // Enable Last-Modified
  index: 'index.html',    // Default file
  setHeaders: (res, path) => {
    if (path.endsWith('.html')) {
      res.setHeader('Cache-Control', 'no-cache');
    }
  }
}));

4. express.raw() – Parse Raw Body

Code
// Parse raw body as Buffer
app.use(express.raw({ type: 'application/octet-stream' }));

app.post('/api/upload', (req, res) => {
  console.log(req.body); // Buffer
  res.json({ size: req.body.length });
});

5. express.text() – Parse Text Body

Code
// Parse plain text body
app.use(express.text({ type: 'text/plain' }));

app.post('/api/text', (req, res) => {
  console.log(req.body); // String
  res.json({ text: req.body });
});

6. Third-party Middleware – morgan, cors, helmet

Installation:

Code
npm install morgan cors helmet compression express-rate-limit

Complete Setup:

Code
// server.js
const express = require('express');
const morgan = require('morgan');
const cors = require('cors');
const helmet = require('helmet');
const compression = require('compression');
const rateLimit = require('express-rate-limit');

const app = express();

// ============ 1. Helmet – Security Headers ============
app.use(helmet());

// ============ 2. CORS – Cross-Origin Resource Sharing ============
app.use(cors());
// Custom CORS
app.use(cors({
  origin: 'https://myfrontend.com',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true
}));

// ============ 3. Morgan – HTTP Request Logging ============
app.use(morgan('dev'));
// Other formats: 'combined', 'common', 'short', 'tiny'

// Custom morgan format
app.use(morgan(':method :url :status :response-time ms - :date[iso]'));

// ============ 4. Compression – Response Compression ============
app.use(compression());

// ============ 5. Rate Limiting ============
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP',
  standardHeaders: true,
  legacyHeaders: false
});
app.use('/api', limiter);

// ============ 6. Body Parsers ============
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true }));

// ============ 7. Static Files ============
app.use(express.static('public'));

// Routes
app.get('/', (req, res) => {
  res.json({ message: 'Server is running!' });
});

app.get('/api/data', (req, res) => {
  res.json({ data: 'Protected data' });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

7. Error-handling Middleware – 4 Parameters

Error-handling middleware में 4 parameters (err, req, res, next) होते हैं।

Basic Error Handler:

Code
const express = require('express');
const app = express();

// Custom error class
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
  }
}

// Routes that might throw errors
app.get('/api/users/:id', (req, res, next) => {
  const id = parseInt(req.params.id);
  
  if (isNaN(id)) {
    // Pass error to error handler
    return next(new AppError('Invalid user ID', 400));
  }
  
  if (id > 100) {
    return next(new AppError('User not found', 404));
  }
  
  res.json({ id, name: 'Rahul' });
});

app.post('/api/users', (req, res, next) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return next(new AppError('Name and email required', 400));
  }
  
  res.status(201).json({ message: 'User created' });
});

// ============ 404 Handler (not error middleware) ============
app.use('*', (req, res) => {
  res.status(404).json({
    success: false,
    error: `Cannot ${req.method} ${req.url}`
  });
});

// ============ Global Error Handler ============
app.use((err, req, res, next) => {
  // Log error
  console.error('ERROR:', err);
  
  // Set status code
  const statusCode = err.statusCode || 500;
  
  // Send response
  res.status(statusCode).json({
    success: false,
    error: {
      message: err.isOperational ? err.message : 'Internal server error',
      statusCode,
      ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
    }
  });
});

app.listen(3000);

Async Error Handler Wrapper:

Code
// utils/asyncHandler.js
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

module.exports = asyncHandler;
JavaScript
// routes/users.js
const express = require('express');
const asyncHandler = require('../utils/asyncHandler');
const router = express.Router();

// Without asyncHandler – need try-catch
router.get('/posts/:id', async (req, res, next) => {
  try {
    const post = await db.findPost(req.params.id);
    res.json(post);
  } catch (error) {
    next(error);
  }
});

// With asyncHandler – cleaner!
router.get('/comments/:id', asyncHandler(async (req, res) => {
  const comments = await db.findComments(req.params.id);
  res.json(comments);
}));

module.exports = router;

Multiple Error Handlers:

Code
// Different error handlers for different scenarios

// Validation error handler
app.use((err, req, res, next) => {
  if (err.name === 'ValidationError') {
    return res.status(400).json({
      error: 'Validation failed',
      details: err.details
    });
  }
  next(err);
});

// Database error handler
app.use((err, req, res, next) => {
  if (err.code === 'ER_DUP_ENTRY') {
    return res.status(409).json({
      error: 'Duplicate entry',
      message: err.message
    });
  }
  next(err);
});

// JWT error handler
app.use((err, req, res, next) => {
  if (err.name === 'JsonWebTokenError') {
    return res.status(401).json({
      error: 'Invalid token',
      message: 'Please login again'
    });
  }
  next(err);
});

// Default error handler (must be last)
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({
    error: 'Internal server error',
    message: process.env.NODE_ENV === 'development' ? err.message : undefined
  });
});

8. Custom Middleware – अपना Middleware लिखो

1. Request Timer Middleware:

Code
// middleware/timer.js
function requestTimer(req, res, next) {
  const start = Date.now();
  
  // Store start time
  req.startTime = start;
  
  // Capture response finish
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.url} - ${duration}ms`);
    
    // Could add to response header
    res.setHeader('X-Response-Time', `${duration}ms`);
  });
  
  next();
}

module.exports = requestTimer;

2. API Key Middleware:

Code
// middleware/apiKey.js
const validApiKeys = [
  'key-123',
  'key-456',
  'key-789'
];

function apiKeyAuth(req, res, next) {
  const apiKey = req.headers['x-api-key'];
  
  if (!apiKey) {
    return res.status(401).json({
      error: 'API key required',
      message: 'Please provide x-api-key header'
    });
  }
  
  if (!validApiKeys.includes(apiKey)) {
    return res.status(403).json({
      error: 'Invalid API key',
      message: 'The provided API key is not valid'
    });
  }
  
  // Store API key info
  req.apiKey = apiKey;
  next();
}

module.exports = apiKeyAuth;

3. Request Validator Middleware:

Code
// middleware/validator.js
function validateUser(req, res, next) {
  const { name, email, age } = req.body;
  const errors = [];
  
  if (!name || name.length < 2) {
    errors.push('Name must be at least 2 characters');
  }
  
  if (!email || !email.includes('@')) {
    errors.push('Valid email is required');
  }
  
  if (age && (age < 18 || age > 100)) {
    errors.push('Age must be between 18 and 100');
  }
  
  if (errors.length > 0) {
    return res.status(400).json({
      error: 'Validation failed',
      details: errors
    });
  }
  
  next();
}

module.exports = validateUser;

4. Rate Limiter Middleware:

Code
// middleware/rateLimiter.js
const requestCounts = new Map();

function rateLimiter(limit = 10, windowMs = 60000) {
  return (req, res, next) => {
    const ip = req.ip;
    const now = Date.now();
    
    if (!requestCounts.has(ip)) {
      requestCounts.set(ip, {
        count: 1,
        firstRequest: now
      });
      return next();
    }
    
    const userData = requestCounts.get(ip);
    
    if (now - userData.firstRequest < windowMs) {
      if (userData.count >= limit) {
        return res.status(429).json({
          error: 'Too many requests',
          message: `Limit of ${limit} requests per ${windowMs/1000} seconds exceeded`,
          retryAfter: Math.ceil((windowMs - (now - userData.firstRequest)) / 1000)
        });
      }
      userData.count++;
    } else {
      userData.count = 1;
      userData.firstRequest = now;
    }
    
    // Add rate limit headers
    res.setHeader('X-RateLimit-Limit', limit);
    res.setHeader('X-RateLimit-Remaining', limit - userData.count);
    res.setHeader('X-RateLimit-Reset', userData.firstRequest + windowMs);
    
    next();
  };
}

module.exports = rateLimiter;

5. Using Custom Middleware:

Code
// server.js
const express = require('express');
const requestTimer = require('./middleware/timer');
const apiKeyAuth = require('./middleware/apiKey');
const validateUser = require('./middleware/validator');
const rateLimiter = require('./middleware/rateLimiter');

const app = express();

app.use(express.json());

// Global middleware
app.use(requestTimer);

// Public routes (no API key)
app.get('/', (req, res) => {
  res.json({ message: 'Public endpoint' });
});

// Protected routes (require API key)
app.use('/api', rateLimiter(20, 60000));
app.use('/api', apiKeyAuth);

app.get('/api/data', (req, res) => {
  res.json({ message: 'Protected data', apiKey: req.apiKey });
});

app.post('/api/users', validateUser, (req, res) => {
  res.status(201).json({ message: 'User created', user: req.body });
});

app.listen(3000);

9. Middleware Order – Importance

Middleware order very important है – jis order mein likhoge, usi order mein execute honge।

Correct Order:

Code
const express = require('express');
const app = express();

// ✅ CORRECT ORDER

// 1. Security middleware first
app.use(helmet());
app.use(cors());

// 2. Logging
app.use(morgan('dev'));

// 3. Body parsers
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 4. Authentication
app.use(authenticate);

// 5. Rate limiting
app.use(rateLimiter);

// 6. Routes
app.get('/api/users', getUsers);
app.post('/api/users', createUser);

// 7. 404 handler
app.use('*', notFoundHandler);

// 8. Error handler (LAST!)
app.use(errorHandler);

Wrong Order Example:

Code
// ❌ WRONG ORDER

// Body parser after routes – won't work!
app.get('/api/users', (req, res) => {
  console.log(req.body); // undefined!
});
app.use(express.json()); // Too late!

// 404 before routes – routes never reached!
app.use('*', (req, res) => {
  res.status(404).send('Not Found');
});
app.get('/api/users', getUsers); // Never reaches!

// Error handler before routes – won't catch errors!
app.use(errorHandler);
app.get('/api/users', getUsers); // Error handler won't catch route errors

10. Multiple Middleware – Chaining

Array of Middleware:

Code
// Multiple middleware as array
const middleware1 = (req, res, next) => {
  console.log('1');
  next();
};

const middleware2 = (req, res, next) => {
  console.log('2');
  next();
};

const middleware3 = (req, res, next) => {
  console.log('3');
  next();
};

app.get('/api/data', [middleware1, middleware2, middleware3], (req, res) => {
  res.json({ message: 'Data' });
});

// Output: 1, 2, 3, then route handler

Conditional Middleware:

Code
// Apply middleware conditionally
const authMiddleware = (req, res, next) => {
  // Check if route needs auth
  const publicRoutes = ['/', '/login', '/register'];
  
  if (publicRoutes.includes(req.path)) {
    return next(); // Skip auth
  }
  
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  // Verify token
  try {
    const decoded = jwt.verify(token, SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

app.use(authMiddleware);

11. Real-world Examples

Complete Authentication Middleware System:

Code
// middleware/auth.js
const jwt = require('jsonwebtoken');
const { findUserById } = require('../services/userService');

// Authentication middleware
async function authenticate(req, res, next) {
  try {
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        error: 'Authentication required',
        message: 'Please provide a valid token'
      });
    }
    
    const token = authHeader.split(' ')[1];
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    
    const user = await findUserById(decoded.id);
    if (!user) {
      return res.status(401).json({
        error: 'User not found',
        message: 'The user associated with this token no longer exists'
      });
    }
    
    req.user = user;
    next();
  } catch (error) {
    if (error.name === 'JsonWebTokenError') {
      return res.status(401).json({ error: 'Invalid token' });
    }
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ error: 'Token expired' });
    }
    next(error);
  }
}

// Authorization middleware
function authorize(...roles) {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
    
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        error: 'Forbidden',
        message: `Role '${req.user.role}' does not have access to this resource`
      });
    }
    
    next();
  };
}

// Resource ownership middleware
function isOwner(getResourceUserId) {
  return async (req, res, next) => {
    const resourceUserId = await getResourceUserId(req);
    
    if (req.user.role === 'admin' || req.user.id === resourceUserId) {
      return next();
    }
    
    res.status(403).json({
      error: 'Forbidden',
      message: 'You can only access your own resources'
    });
  };
}

module.exports = { authenticate, authorize, isOwner };

Using the Auth Middleware:

Code
// server.js
const express = require('express');
const { authenticate, authorize, isOwner } = require('./middleware/auth');

const app = express();

// Public routes
app.post('/api/login', loginHandler);
app.post('/api/register', registerHandler);

// Protected routes (all need auth)
app.use('/api', authenticate);

// User routes (user can access own profile)
app.get('/api/users/profile', (req, res) => {
  res.json({ user: req.user });
});

app.put('/api/users/profile', (req, res) => {
  // Update own profile
  res.json({ message: 'Profile updated' });
});

// Admin only routes
app.get('/api/admin/users', authorize('admin'), (req, res) => {
  res.json({ users: allUsers });
});

app.delete('/api/admin/users/:id', authorize('admin'), (req, res) => {
  res.json({ message: `User ${req.params.id} deleted` });
});

// Resource ownership check
app.get('/api/orders/:id', isOwner(async (req) => {
  const order = await db.findOrder(req.params.id);
  return order.userId;
}), (req, res) => {
  res.json({ order });
});

app.listen(3000);

12. Common Mistakes + Solutions

Mistake 1: Forgetting to call next()

Code
// ❌ Request hangs
app.use((req, res, next) => {
  console.log('Middleware');
  // Missing next()!
});

// ✅ Call next()
app.use((req, res, next) => {
  console.log('Middleware');
  next();
});

Mistake 2: Sending response multiple times

Code
// ❌ Error: Cannot set headers after they are sent
app.use((req, res, next) => {
  res.json({ message: 'First' });
  next(); // Trying to send again in route!
});

// ✅ Send only once
app.use((req, res, next) => {
  // Either send response OR call next(), not both
  if (someCondition) {
    res.json({ message: 'Response' });
  } else {
    next();
  }
});

Mistake 3: Error middleware wrong parameter count

Code
// ❌ Not error middleware (3 parameters)
app.use((err, req, res) => {
  res.status(500).json({ error: err.message });
});

// ✅ Error middleware (4 parameters)
app.use((err, req, res, next) => {
  res.status(500).json({ error: err.message });
});

Mistake 4: Middleware order

Code
// ❌ Body parser after routes
app.get('/api/users', handler);
app.use(express.json());

// ✅ Body parser before routes
app.use(express.json());
app.get('/api/users', handler);

13. Quick Cheat Sheet

Middleware Types:

TypeMethodScope
Applicationapp.use()Whole app
Routerrouter.use()Specific router
Built-inexpress.json()Parse JSON
Third-partyrequire('morgan')Logging
Error(err, req, res, next)Error handling

Common Middleware:

MiddlewarePurposeInstallation
express.json()Parse JSONBuilt-in
express.urlencoded()Parse formsBuilt-in
express.static()Serve static filesBuilt-in
morganHTTP loggingnpm i morgan
corsCORS supportnpm i cors
helmetSecurity headersnpm i helmet
compressionResponse compressionnpm i compression
express-rate-limitRate limitingnpm i express-rate-limit

Middleware Flow:

Code
app.use(m1);
app.use(m2);
app.use(m3);

// Request → m1 → m2 → m3 → Route → Response

14. FAQ

Q1: Express middleware Hindi में सबसे important concept kya hai?
next() function – ye agla middleware call karta hai। Bina next() ke request aage nahi badhti।

Q2: app.use() vs app.get() – kya antar hai?
app.use() sab HTTP methods ke liye middleware apply karta hai। app.get() sirf GET requests के लिए।

Q3: Error middleware mein 4 parameters kyun?
Express error middleware को 4 parameters से identify करता है (err, req, res, next)। Parameter count different है तो normal middleware समझेगा।

Q4: Middleware order kyun important hai?
Jis order mein likho, usi order mein execute honge। Body parser routes से पहले होना चाहिए, error handler last में।

Q5: next('route') kya karta hai?
Current middleware chain skip karta hai aur next matching route par jump kar jata hai।

Q6: Custom middleware kaise likhein?
Function jo (req, res, next) parameters leta ho, logic execute kare, aur next() call kare।

Q7: Built-in vs third-party middleware – kya antar hai?
Built-in – Express ke saath aata hai (express.json, express.static)। Third-party – npm install karna padta hai।

Q8: express.json() aur express.urlencoded() mein kya antar hai?
express.json() – JSON request body parse karta है। express.urlencoded() – HTML form data parse karta है।

Q9: Error middleware last mein kyun lagana chahiye?
Taki pehले सभी routes aur middleware errors throw kar sake, aur error handler unhe catch kare।

Q10: Multiple middleware kaise chain karein?
Array में pass karo: app.get('/path', [m1, m2, m3], handler)

15. Conclusion

बहुत बढ़िया दोस्तों! आज हमने Express middleware Hindi को पूरी detail में समझा।

Quick Recap:

Middleware TypeKey Takeaway
Application-levelapp.use() – whole app
Router-levelrouter.use() – specific routes
Built-inexpress.json, express.static
Third-partymorgan, cors, helmet
Error-handling4 parameters, last middleware

Mera personal experience:

Middleware samajhne ke baad Express.js ka real power samajh aaya। Authentication, logging, validation – sab middleware se hota है। Error middleware ne debugging bohot easy kar di।

Tum bhi ye steps follow karo:

  1. ✅ Basic logger middleware likho
  2. ✅ express.json() use karo
  3. ✅ morgan + cors add karo
  4. ✅ Custom auth middleware likho
  5. ✅ Error handler implement karo

अब तुम्हारी बारी है!

नीचे comment में बताओ:

  1. तुमने कौन सा middleware pehle use kiya?
  2. क्या तुमने कभी custom middleware likha है?
  3. अगला topic क्या चाहिए? (MongoDB? Authentication? File Upload?)

The Easy Master पर बने रहो। Happy Middleware Coding! 🚀💻

Resources

Additional Resources

Post Views: 253
TheEasyMaster

Author at The Easy Master.

Related posts

Backend

2. JWT Authentication Node.js – Secure Login System बनाए 2026

नमस्ते दोस्तों! 🙏स्वागत है The Easy Master पर! क्या तुमने कभी सोचा है – Login system kaise kaam karta hai? Jaise tum Gmail ya Instagram mein…

April 20, 2026 18 min read
3. Node.js MongoDB Connection – Mongoose Setup समझे 2026
Backend

3. Node.js MongoDB Connection – Mongoose Setup समझे 2026

नमस्ते दोस्तों! 🙏स्वागत है The Easy Master पर! क्या तुमने कभी सोचा है – Node.js app ko MongoDB se connect कैसे करें? Database se…

April 28, 2026 18 min read
1. MongoDB Setup – CRUD Operations समझे (Beginner Guide) 2026
Backend

1. MongoDB Setup – CRUD Operations समझे (Beginner Guide) 2026

नमस्ते दोस्तों! 🙏स्वागत है The Easy Master पर! क्या तुमने कभी सोचा है – Data कहाँ store होता है? जब तुम Instagram पर post…

April 26, 2026 12 min read

Leave a Reply

Your email address will not be published. Required fields are marked *