Skip to content
BackendExpressJsNodeJs

7. Express Router – API Routes को Organize करें (Modular Code)

April 24, 2026 19 min read
7. Express Router – API Routes को Organize करें (Modular Code)

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

क्या तुमने कभी सोचा है – जब API बड़ी हो जाती है (100+ routes), तो सारे routes ek file में कैसे manage honge?

सब कुछ server.js में लिखने से file बहुत बड़ी हो जाती है – maintain करना मुश्किल हो जाता है। यहाँ Express Router काम आता है।

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

  • Code organization – routes अलग-अलग files में बांटो
  • Reusability – same router multiple jagah use करो
  • Middleware – specific routes ke liye alag middleware
  • Maintainability – ek jagah change करो, सब jagah effect
  • Team collaboration – अलग-अलग developers अलग-अलग routes files पर काम कर सकते हैं

Aaj kya seekhoge?

TopicKya Seekhega?
Router Kya Hai?Express.Router() introduction
Basic RouterPehla router banayenge
Router MethodsGET, POST, PUT, DELETE
Router MiddlewareRoute-specific middleware
Nested RoutersRoutes ke andar routes
Router Parametersrouter.param()
Modular StructureComplete project organization
Real ProjectE-commerce API with routers

Kya tumhe pata hai?
Express Router mini-application की तरह काम करता है – इसका अपना middleware, routes, aur even error handling हो सकता है!

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

1. Express Router क्या Hai? – Introduction

Express Router ek mini Express application है – जिसका अपना middleware, routes, और logic हो सकता है।

Without Router (All in one file):

Code
// ❌ server.js – सब कुछ एक file में (500+ lines!)
const express = require('express');
const app = express();

// User routes
app.get('/api/users', getAllUsers);
app.get('/api/users/:id', getUserById);
app.post('/api/users', createUser);
app.put('/api/users/:id', updateUser);
app.delete('/api/users/:id', deleteUser);

// Product routes
app.get('/api/products', getAllProducts);
app.get('/api/products/:id', getProductById);
app.post('/api/products', createProduct);
app.put('/api/products/:id', updateProduct);
app.delete('/api/products/:id', deleteProduct);

// Order routes (50 more lines...)
// Cart routes (50 more lines...)
// Payment routes (50 more lines...)

app.listen(3000);

With Router (Organized):

Code
// ✅ server.js – clean & organized
const express = require('express');
const app = express();

const userRoutes = require('./routes/users');
const productRoutes = require('./routes/products');
const orderRoutes = require('./routes/orders');

app.use('/api/users', userRoutes);
app.use('/api/products', productRoutes);
app.use('/api/orders', orderRoutes);

app.listen(3000);
Code
// routes/users.js – all user routes in one file
const express = require('express');
const router = express.Router();

router.get('/', getAllUsers);
router.get('/:id', getUserById);
router.post('/', createUser);
router.put('/:id', updateUser);
router.delete('/:id', deleteUser);

module.exports = router;

Express router API routes organize Hindi में हम professional project structure बनाएंगे।

2. Why Router? – Benefits

Benefits of Using Express Router:

BenefitExplanation
ModularityRoutes अलग-अलग files में बांटो
ReusabilitySame router multiple places use करो
Middleware ScopeSpecific routes ke liye alag middleware
Clean Codeserver.js में sirf mounting
Team Workअलग-अलग developers अलग routers पर काम
TestingEach router can be tested independently
MaintenanceBug fix sirf ek file mein

Visual Comparison:

Express Router API Routes Organize

3. Basic Router – Pehla Router Banayein

Step 1: Create Router File

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

// Mock database
let users = [
  { id: 1, name: 'Rahul', email: 'rahul@example.com' },
  { id: 2, name: 'Priya', email: 'priya@example.com' }
];

// GET /api/users
router.get('/', (req, res) => {
  res.json({
    success: true,
    count: users.length,
    data: users
  });
});

// GET /api/users/:id
router.get('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const user = users.find(u => u.id === id);
  
  if (!user) {
    return res.status(404).json({ error: 'User not found' });
  }
  
  res.json({ success: true, data: user });
});

// POST /api/users
router.post('/', (req, res) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return res.status(400).json({ error: 'Name and email required' });
  }
  
  const newUser = {
    id: users.length + 1,
    name,
    email,
    createdAt: new Date()
  };
  
  users.push(newUser);
  res.status(201).json({ success: true, data: newUser });
});

// PUT /api/users/:id
router.put('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const { name, email } = req.body;
  
  const userIndex = users.findIndex(u => u.id === id);
  
  if (userIndex === -1) {
    return res.status(404).json({ error: 'User not found' });
  }
  
  users[userIndex] = {
    ...users[userIndex],
    name: name || users[userIndex].name,
    email: email || users[userIndex].email,
    updatedAt: new Date()
  };
  
  res.json({ success: true, data: users[userIndex] });
});

// DELETE /api/users/:id
router.delete('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const userIndex = users.findIndex(u => u.id === id);
  
  if (userIndex === -1) {
    return res.status(404).json({ error: 'User not found' });
  }
  
  users.splice(userIndex, 1);
  res.json({ success: true, message: 'User deleted' });
});

module.exports = router;

Step 2: Import and Use in Main File

Code
// server.js
const express = require('express');
const app = express();

app.use(express.json());

// Import routers
const userRoutes = require('./routes/users');
const productRoutes = require('./routes/products');

// Use routers
app.use('/api/users', userRoutes);
app.use('/api/products', productRoutes);

app.listen(3000, () => {
  console.log('Server running on port 3000');
  console.log('Users API: http://localhost:3000/api/users');
});

4. Router Methods – GET, POST, PUT, DELETE

Router methods app methods की तरह ही काम करते हैं।

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

let products = [
  { id: 1, name: 'Laptop', price: 50000 },
  { id: 2, name: 'Mouse', price: 500 }
];

// GET all
router.get('/', (req, res) => {
  res.json(products);
});

// GET single
router.get('/:id', (req, res) => {
  const product = products.find(p => p.id === parseInt(req.params.id));
  if (!product) return res.status(404).json({ error: 'Not found' });
  res.json(product);
});

// POST
router.post('/', (req, res) => {
  const { name, price } = req.body;
  const newProduct = {
    id: products.length + 1,
    name,
    price
  };
  products.push(newProduct);
  res.status(201).json(newProduct);
});

// PUT
router.put('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const { name, price } = req.body;
  const index = products.findIndex(p => p.id === id);
  
  if (index === -1) return res.status(404).json({ error: 'Not found' });
  
  products[index] = { ...products[index], name, price };
  res.json(products[index]);
});

// PATCH
router.patch('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const updates = req.body;
  const index = products.findIndex(p => p.id === id);
  
  if (index === -1) return res.status(404).json({ error: 'Not found' });
  
  products[index] = { ...products[index], ...updates };
  res.json(products[index]);
});

// DELETE
router.delete('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const index = products.findIndex(p => p.id === id);
  
  if (index === -1) return res.status(404).json({ error: 'Not found' });
  
  products.splice(index, 1);
  res.status(204).send();
});

// ALL method (any HTTP method)
router.all('/health', (req, res) => {
  res.json({ status: 'OK', method: req.method });
});

module.exports = router;

5. Router Middleware – Route-specific Middleware

Router-level Middleware:

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

// Middleware specific to this router (runs for all routes in this router)
router.use((req, res, next) => {
  console.log(`[ADMIN] ${req.method} ${req.url} - ${new Date().toISOString()}`);
  next();
});

// Authentication middleware for admin routes
const authenticateAdmin = (req, res, next) => {
  const token = req.headers.authorization;
  
  if (!token || token !== 'Bearer admin-secret') {
    return res.status(401).json({ error: 'Admin access required' });
  }
  
  next();
};

// Apply to all routes in this router
router.use(authenticateAdmin);

// Routes (all require admin auth)
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: `User ${req.params.id} deleted` });
});

module.exports = router;

Route-specific Middleware:

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

// Middleware for specific route
const validatePost = (req, res, next) => {
  const { title, content } = req.body;
  
  if (!title || title.length < 5) {
    return res.status(400).json({ error: 'Title must be at least 5 characters' });
  }
  
  if (!content || content.length < 10) {
    return res.status(400).json({ error: 'Content must be at least 10 characters' });
  }
  
  next();
};

const checkOwnership = (req, res, next) => {
  const postId = req.params.id;
  const userId = req.user.id;
  
  // Check if user owns the post
  if (postId && !isOwner(postId, userId)) {
    return res.status(403).json({ error: 'You can only edit your own posts' });
  }
  
  next();
};

// Apply multiple middleware to route
router.post('/', validatePost, (req, res) => {
  // Create post (validation already passed)
  res.status(201).json({ message: 'Post created' });
});

router.put('/:id', validatePost, checkOwnership, (req, res) => {
  // Update post (validation + ownership check passed)
  res.json({ message: 'Post updated' });
});

module.exports = router;

Middleware Array for Clean Code:

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

// Define middleware as array for reusability
const authMiddleware = [
  (req, res, next) => {
    console.log('Auth step 1: Check token');
    next();
  },
  (req, res, next) => {
    console.log('Auth step 2: Verify user');
    next();
  },
  (req, res, next) => {
    console.log('Auth step 3: Set user in request');
    req.user = { id: 1, name: 'Rahul' };
    next();
  }
];

const loggingMiddleware = [
  (req, res, next) => {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
    next();
  },
  (req, res, next) => {
    console.log(`User: ${req.user?.name || 'Guest'}`);
    next();
  }
];

// Apply multiple middleware arrays
router.get('/protected', [...authMiddleware, ...loggingMiddleware], (req, res) => {
  res.json({ message: 'Protected data', user: req.user });
});

module.exports = router;

6. Router Parameters – router.param()

router.param() specific parameter ke liye middleware बनाने के लिए।

Basic router.param():

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

// Middleware that runs for any route with :userId parameter
router.param('userId', (req, res, next, userId) => {
  console.log(`Processing user ID: ${userId}`);
  
  // Validate userId
  const id = parseInt(userId);
  if (isNaN(id)) {
    return res.status(400).json({ error: 'Invalid user ID format' });
  }
  
  // Fetch user from database and attach to request
  const user = users.find(u => u.id === id);
  if (!user) {
    return res.status(404).json({ error: 'User not found' });
  }
  
  req.user = user; // Attach to request
  next();
});

// Now these routes don't need to fetch user again!
router.get('/:userId', (req, res) => {
  // req.user is already available from param middleware
  res.json({ success: true, data: req.user });
});

router.put('/:userId', (req, res) => {
  // Update using req.user
  const { name, email } = req.body;
  req.user.name = name || req.user.name;
  req.user.email = email || req.user.email;
  res.json({ success: true, data: req.user });
});

router.delete('/:userId', (req, res) => {
  // Delete using req.user
  const index = users.findIndex(u => u.id === req.user.id);
  users.splice(index, 1);
  res.json({ success: true, message: 'User deleted' });
});

Multiple Parameters:

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

// Parameter middleware for userId
router.param('userId', (req, res, next, userId) => {
  req.user = users.find(u => u.id === parseInt(userId));
  if (!req.user) {
    return res.status(404).json({ error: 'User not found' });
  }
  next();
});

// Parameter middleware for postId
router.param('postId', (req, res, next, postId) => {
  req.post = posts.find(p => p.id === parseInt(postId));
  if (!req.post) {
    return res.status(404).json({ error: 'Post not found' });
  }
  next();
});

// Route with both parameters
router.get('/users/:userId/posts/:postId', (req, res) => {
  // Both req.user and req.post are available
  res.json({
    user: req.user,
    post: req.post
  });
});

7. Nested Routers – Routes Ke Andar Routes

Project Structure for Nested Routes:

Code
routes/
├── index.js
├── v1/
│   ├── index.js
│   ├── users.js
│   └── products.js
└── v2/
    ├── index.js
    ├── users.js
    └── products.js

Nested Router Example:

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

// Posts sub-router (nested)
const postsRouter = require('./posts');

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

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

// Mount posts router on /:userId/posts
router.use('/:userId/posts', postsRouter);

module.exports = router;
Code
// routes/v1/posts.js
const express = require('express');
const router = express.Router({ mergeParams: true }); // mergeParams is IMPORTANT!

// Now we can access userId from parent router
router.get('/', (req, res) => {
  const userId = req.params.userId;
  res.json({ message: `V1 - All posts for user ${userId}` });
});

router.get('/:postId', (req, res) => {
  const { userId, postId } = req.params;
  res.json({ message: `V1 - Post ${postId} for user ${userId}` });
});

module.exports = router;
Code
// routes/v1/index.js
const express = require('express');
const router = express.Router();

const userRoutes = require('./users');
const productRoutes = require('./products');

router.use('/users', userRoutes);
router.use('/products', productRoutes);

module.exports = router;
Code
// server.js
const express = require('express');
const app = express();

const v1Routes = require('./routes/v1');
const v2Routes = require('./routes/v2');

// Versioned APIs
app.use('/api/v1', v1Routes);
app.use('/api/v2', v2Routes);

// URLs:
// GET /api/v1/users
// GET /api/v1/users/123
// GET /api/v1/users/123/posts
// GET /api/v1/users/123/posts/456

8. Modular Project Structure

Complete Professional Structure:

Code
my-ecommerce-api/
├── server.js
├── package.json
├── .env
├── config/
│   ├── database.js
│   └── constants.js
├── middleware/
│   ├── auth.js
│   ├── errorHandler.js
│   ├── validation.js
│   └── rateLimiter.js
├── routes/
│   ├── index.js
│   ├── v1/
│   │   ├── index.js
│   │   ├── auth.js
│   │   ├── users.js
│   │   ├── products.js
│   │   ├── orders.js
│   │   └── cart.js
│   └── v2/
│       └── index.js
├── controllers/
│   ├── authController.js
│   ├── userController.js
│   ├── productController.js
│   └── orderController.js
├── services/
│   ├── userService.js
│   ├── productService.js
│   └── emailService.js
├── models/
│   ├── User.js
│   ├── Product.js
│   └── Order.js
├── utils/
│   ├── jwt.js
│   ├── bcrypt.js
│   └── validators.js
└── tests/
    ├── routes/
    └── controllers/

Main Router (routes/index.js):

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

const v1Routes = require('./v1');
const v2Routes = require('./v2');

// Health check
router.get('/health', (req, res) => {
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

// API versions
router.use('/v1', v1Routes);
router.use('/v2', v2Routes);

module.exports = router;

Version 1 Router (routes/v1/index.js):

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

const authRoutes = require('./auth');
const userRoutes = require('./users');
const productRoutes = require('./products');
const orderRoutes = require('./orders');
const cartRoutes = require('./cart');

// Public routes
router.use('/auth', authRoutes);

// Protected routes (require authentication)
router.use('/users', userRoutes);
router.use('/products', productRoutes);
router.use('/orders', orderRoutes);
router.use('/cart', cartRoutes);

module.exports = router;

Complete Server File:

Code
// server.js
require('dotenv').config();
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

const app = express();

// Middleware
app.use(helmet());
app.use(cors());
app.use(morgan('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Database connection
mongoose.connect(process.env.MONGODB_URI);

// Routes
const apiRoutes = require('./routes');
app.use('/api', apiRoutes);

// 404 handler
app.use('*', (req, res) => {
  res.status(404).json({ error: `Cannot ${req.method} ${req.originalUrl}` });
});

// Global error handler
app.use(require('./middleware/errorHandler'));

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`🚀 Server running on port ${PORT}`);
  console.log(`📝 API: http://localhost:${PORT}/api`);
  console.log(`📚 API v1: http://localhost:${PORT}/api/v1`);
  console.log(`📚 API v2: http://localhost:${PORT}/api/v2`);
});

9. Complete E-commerce API Example

User Routes (routes/v1/users.js):

Code
// routes/v1/users.js
const express = require('express');
const router = express.Router();
const { authenticate, authorize } = require('../../middleware/auth');
const { validateUser, validateUserUpdate } = require('../../middleware/validation');
const userController = require('../../controllers/userController');

// Public routes (no auth needed)
router.post('/register', validateUser, userController.register);
router.post('/login', userController.login);
router.post('/forgot-password', userController.forgotPassword);
router.post('/reset-password', userController.resetPassword);

// All routes below require authentication
router.use(authenticate);

// Profile routes
router.get('/profile', userController.getProfile);
router.put('/profile', validateUserUpdate, userController.updateProfile);
router.delete('/profile', userController.deleteProfile);

// Admin only routes
router.get('/', authorize('admin'), userController.getAllUsers);
router.get('/:id', authorize('admin'), userController.getUserById);
router.put('/:id', authorize('admin'), validateUserUpdate, userController.updateUserByAdmin);
router.delete('/:id', authorize('admin'), userController.deleteUserByAdmin);

module.exports = router;

Product Routes (routes/v1/products.js):

Code
// routes/v1/products.js
const express = require('express');
const router = express.Router();
const { authenticate, authorize } = require('../../middleware/auth');
const { validateProduct } = require('../../middleware/validation');
const productController = require('../../controllers/productController');

// Public routes (anyone can view products)
router.get('/', productController.getAllProducts);
router.get('/categories', productController.getCategories);
router.get('/search', productController.searchProducts);
router.get('/:id', productController.getProductById);

// Admin only routes
router.post('/', authenticate, authorize('admin'), validateProduct, productController.createProduct);
router.put('/:id', authenticate, authorize('admin'), validateProduct, productController.updateProduct);
router.delete('/:id', authenticate, authorize('admin'), productController.deleteProduct);
router.patch('/:id/stock', authenticate, authorize('admin'), productController.updateStock);

// Review routes (nested)
const reviewRoutes = require('./reviews');
router.use('/:productId/reviews', reviewRoutes);

module.exports = router;

Review Routes (nested):

Code
// routes/v1/reviews.js
const express = require('express');
const router = express.Router({ mergeParams: true });
const { authenticate } = require('../../middleware/auth');
const reviewController = require('../../controllers/reviewController');

// Get all reviews for a product (public)
router.get('/', reviewController.getProductReviews);

// Protected review routes
router.use(authenticate);

router.post('/', reviewController.createReview);
router.put('/:reviewId', reviewController.updateReview);
router.delete('/:reviewId', reviewController.deleteReview);

module.exports = router;

Order Routes:

Code
// routes/v1/orders.js
const express = require('express');
const router = express.Router();
const { authenticate, authorize } = require('../../middleware/auth');
const orderController = require('../../controllers/orderController');

// All order routes require authentication
router.use(authenticate);

// User order routes
router.post('/', orderController.createOrder);
router.get('/my-orders', orderController.getMyOrders);
router.get('/my-orders/:id', orderController.getMyOrderById);
router.post('/:id/cancel', orderController.cancelOrder);

// Admin only routes
router.get('/', authorize('admin'), orderController.getAllOrders);
router.get('/:id', authorize('admin'), orderController.getOrderById);
router.put('/:id/status', authorize('admin'), orderController.updateOrderStatus);

module.exports = router;

10. Common Mistakes + Solutions

Mistake 1: Forgetting to export router

Code
// ❌ Missing module.exports
const router = express.Router();
router.get('/', handler);

// ✅ Export router
module.exports = router;

Mistake 2: Not using mergeParams for nested routers

Code
// ❌ Parent params not accessible in child router
const childRouter = express.Router();
// childRouter can't access req.params.userId from parent

// ✅ Use mergeParams: true
const childRouter = express.Router({ mergeParams: true });

Mistake 3: Router middleware order

Code
// ❌ Wrong order – middleware after routes
router.get('/', handler);
router.use(authMiddleware);

// ✅ Correct – middleware before routes
router.use(authMiddleware);
router.get('/', handler);

Mistake 4: Multiple routers with same path

Code
// ❌ This will work but order matters
app.use('/api/users', userRoutes);
app.use('/api/users', adminRoutes); // Only first will be used

// ✅ Different paths or combine in one router
app.use('/api/users', userRoutes);
app.use('/api/admin/users', adminRoutes);

11. Quick Cheat Sheet

Router Setup:

Code
const express = require('express');
const router = express.Router();

// Routes
router.get('/', handler);

module.exports = router;

Router Methods:

MethodPurpose
router.get()Read data
router.post()Create data
router.put()Full update
router.patch()Partial update
router.delete()Delete data
router.use()Mount middleware/router
router.route()Chain multiple methods
router.param()Parameter middleware

Mounting Routers:

Code
// In server.js
app.use('/api/users', userRoutes);
app.use('/api/products', productRoutes);
app.use('/api/v1', v1Routes);

// In route files
router.use('/posts', postRoutes); // Nested

Router Options:

Code
// Merge params for nested routers
const router = express.Router({ mergeParams: true });

// Case sensitive routing
const router = express.Router({ caseSensitive: true });

// Strict routing (trailing slash matters)
const router = express.Router({ strict: true });

12. FAQ

Q1: Express router API routes organize Hindi में सबसे important concept kya hai?
express.Router() – ye mini-application create करता है जिससे routes को अलग-अलग files में organize कर सकते हो।

Q2: app.use() vs router.use() – kya antar hai?
app.use() main application par middleware apply करता है। router.use() specific router par middleware apply करता है।

Q3: Nested routers mein mergeParams: true kyun chahiye?
Parent router के params (jaise :userId) child router में access करने के लिए।

Q4: Multiple routers ko kaise combine karein?
Ek main router बनाओ और उसमें सब routers को mount करो: router.use('/users', userRoutes)।

Q5: Router middleware order kyun important hai?
Middleware jis order में लिखा होता है, उसी order में execute होता है। Auth middleware routes से पहले होना चाहिए।

Q6: router.param() kya karta hai?
Specific route parameter (jaise :userId) के लिए middleware बनाता है जो har request से पहले run होता है।

Q7: Ek file mein multiple routers kaise export karein?

Code
module.exports = { userRouter, productRouter, orderRouter };

Q8: Router ko test kaise karein?
Supertest ya jest se isolated testing कर सकते हो – router को export करो और test file में import करो।

Q9: Versioned APIs (v1, v2) kaise banayein?
अलग-अलग folders बनाओ routes/v1/ और routes/v2/, फिर main server में app.use('/api/v1', v1Routes)।

Q10: Production mein router ka performance?
Router overhead negligible है। Code organization और maintainability के benefits performance से ज्यादा important हैं।

13. Conclusion

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

Quick Recap:

ConceptKey Takeaway
express.Router()Mini-application for routes
Modular StructureRoutes को अलग-अलग files में
Nested RoutersmergeParams: true for parent params
Router MiddlewareRoute-specific middleware
router.param()Parameter-based middleware

Mera personal experience:

Router use करने से पहले मेरा server.js 1000+ lines का हो गया था – navigation और maintenance nightmare था। Router ने code को बहुत clean और organized बना दिया। अब नया feature add करना बहुत easy है – बस नया router file बनाओ और mount करो।

Tum bhi ye steps follow karo:

  1. ✅ Pehla router file banao (routes/users.js)
  2. ✅ Basic CRUD routes implement करो
  3. ✅ Main server में router mount करो
  4. ✅ Nested routers try करो
  5. ✅ Complete project structure adopt करो

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

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

  1. तुम्हारे project में कितने routes हैं?
  2. क्या तुम versioned APIs use करोगे?
  3. अगला topic क्या चाहिए? (MongoDB with Mongoose? JWT Authentication? File Upload?)

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

Resources

Additional Resources

Post Views: 321
TheEasyMaster

Author at The Easy Master.

Related posts

5. Async Await vs Promises – Node.js में Async Code कैसे सीखें?
Backend

5. Async Await vs Promises – Node.js में Async Code कैसे सीखें?

नमस्ते दोस्तों! 🙏स्वागत है The Easy Master पर! क्या तुमने कभी सोचा है – Node.js async code कैसे काम करता है? Callback hell, Promises,…

April 21, 2026 17 min read
7. Next.js Authentication – JWT Session Management (App Router) 2026
Backend

7. Next.js Authentication – JWT Session Management (App Router) 2026

नमस्ते दोस्तों! 🙏 स्वागत है The Easy Master पर! क्या तुमने कभी सोचा है – Next.js App Router में JWT authentication कैसे implement…

May 6, 2026 23 min read
5. TypeScript Utility Types Mastery – Partial Pick Omit समझे 2026
Backend

5. TypeScript Utility Types Mastery – Partial Pick Omit समझे 2026

नमस्ते दोस्तों! 🙏स्वागत है The Easy Master पर! क्या तुमने कभी TypeScript में ऐसे code देखे हैं: type PartialUser = Partial<User>; type UserName…

April 10, 2026 10 min read

Leave a Reply

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