एक्सप्रेस.जेएस का उपयोग करके एक नोड.जेएस एप्लिकेशन विकसित करते समय, अपने कोडबेस को प्रभावी ढंग से संरचित करना रखरखाव, स्केलेबिलिटी और सहयोग में आसानी के लिए महत्वपूर्ण है। एक सुव्यवस्थित परियोजना संरचना आपको जटिलता को प्रबंधित करने की अनुमति देती है, जिससे कोड को नेविगेट करना और समझना आसान हो जाता है। इस ब्लॉग में, हम Express.js एप्लिकेशन के लिए एक विशिष्ट फ़ोल्डर संरचना का पता लगाएंगे और प्रत्येक निर्देशिका और फ़ाइल के उद्देश्य की व्याख्या करेंगे।

प्रोजेक्ट संरचना अवलोकन
यहां Express.js एप्लिकेशन के लिए एक सामान्य फ़ोल्डर संरचना दी गई है:

?
├── ? app.js
├── ? bin
├── ? config
├── ? controllers
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? middleware
│   ├── ? auth.js
│   ├── ? logger.js
│   └── ...
├── ? models
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? routes
│   ├── ? api.js
│   ├── ? auth.js
│   └── ...
├── ? public
│   ├── ? css
│   ├── ? js
│   ├── ? images
│   └── ...
├── ? views
│   ├── ? index.ejs
│   ├── ? product.ejs
│   └── ...
├── ? tests
│   ├── ? unit
│   ├── ? integration
│   ├── ? e2e
│   └── ...
├── ? utils
│   ├── ? validation.js
│   ├── ? helpers.js
│   └── ...
└── ? node_modules

प्रत्येक निर्देशिका और फ़ाइल का स्पष्टीकरण
ऐप.जेएस
App.js फ़ाइल आपके एप्लिकेशन का प्रवेश बिंदु है। यह वह जगह है जहां आप एक्सप्रेस ऐप को इनिशियलाइज़ करते हैं, मिडलवेयर सेट करते हैं, रूट परिभाषित करते हैं और सर्वर शुरू करते हैं। इसे अपने वेब एप्लिकेशन का नियंत्रण केंद्र समझें।

const express = require('express');
const app = express();
const config = require('./config');
const routes = require('./routes');
// Middleware setup
app.use(express.json());
// Routes setup
app.use('/api', routes);
// Start server
const PORT = config.port || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});
module.exports = app;

बिन
बिन निर्देशिका में आमतौर पर आपके वेब सर्वर को शुरू करने के लिए स्क्रिप्ट होती हैं। इन स्क्रिप्ट्स का उपयोग पर्यावरण चर सेट करने या विभिन्न वातावरणों (जैसे, विकास, उत्पादन) को प्रबंधित करने के लिए किया जा सकता है।

उदाहरण: बिन/www

#!/usr/bin/env node
const app = require('../app');
const debug = require('debug')('your-app:server');
const http = require('http');
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
const server = http.createServer(app);
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
function normalizePort(val) {
  const port = parseInt(val, 10);
  if (isNaN(port)) return val;
  if (port >= 0) return port;
  return false;
}
function onError(error) {
  if (error.syscall !== 'listen') throw error;
  const bind = typeof port === 'string' ? 'Pipe '   port : 'Port '   port;
  switch (error.code) {
    case 'EACCES':
      console.error(bind   ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind   ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}
function onListening() {
  const addr = server.address();
  const bind = typeof addr === 'string' ? 'pipe '   addr : 'port '   addr.port;
  debug('Listening on '   bind);
}

कॉन्फिग
कॉन्फ़िगरेशन निर्देशिका आपके एप्लिकेशन के लिए कॉन्फ़िगरेशन फ़ाइलें रखती है, जैसे डेटाबेस कनेक्शन, सर्वर सेटिंग्स और पर्यावरण चर।

उदाहरण: config/index.js

module.exports = {
  port: process.env.PORT || 3000,
  db: {
    host: 'localhost',
    port: 27017,
    name: 'mydatabase'
  }
};

नियंत्रक
नियंत्रकों में आने वाले अनुरोधों को संभालने और प्रतिक्रियाएँ उत्पन्न करने के लिए तर्क होते हैं। नियंत्रक निर्देशिका में प्रत्येक फ़ाइल आम तौर पर आपके एप्लिकेशन के एक अलग हिस्से (जैसे, ग्राहक, उत्पाद) से मेल खाती है।

उदाहरण: नियंत्रक/ग्राहक.जेएस

const Customer = require('../models/customer');
exports.getAllCustomers = async (req, res) => {
  try {
    const customers = await Customer.find();
    res.json(customers);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

मिडलवेयर
मिडलवेयर फ़ंक्शंस का उपयोग अनुरोधों को नियंत्रकों तक पहुंचने से पहले संसाधित करने के लिए किया जाता है। वे प्रमाणीकरण, लॉगिंग और सत्यापन का अनुरोध जैसे कार्य संभाल सकते हैं।

उदाहरण: मिडलवेयर/ऑथ.जेएस

module.exports = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Access Denied' });
  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (err) {
    res.status(400).json({ message: 'Invalid Token' });
  }
};

मॉडल
मॉडल आपके डेटा की संरचना को परिभाषित करते हैं और डेटाबेस के साथ इंटरैक्शन को संभालते हैं। प्रत्येक मॉडल फ़ाइल आम तौर पर एक अलग डेटा इकाई (जैसे, ग्राहक, उत्पाद) से मेल खाती है।

उदाहरण: मॉडल/ग्राहक.जेएस

const mongoose = require('mongoose');
const customerSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
module.exports = mongoose.model('Customer', customerSchema);

मार्ग
रूट आपके एप्लिकेशन के विभिन्न हिस्सों के लिए पथ परिभाषित करते हैं और उन्हें उपयुक्त नियंत्रकों पर मैप करते हैं।

उदाहरण: मार्ग/api.js

const express = require('express');
const router = express.Router();
const customerController = require('../controllers/customer');
router.get('/customers', customerController.getAllCustomers);
module.exports = router;

जनता
सार्वजनिक निर्देशिका में सीएसएस, जावास्क्रिप्ट और छवियों जैसी स्थिर फ़ाइलें होती हैं जो सीधे क्लाइंट को प्रदान की जाती हैं।

उदाहरण: निर्देशिका संरचना

public/
├── css/
├── js/
├── images/

दृश्य
दृश्य ऐसे टेम्प्लेट हैं जो क्लाइंट के लिए HTML प्रस्तुत करते हैं। ईजेएस, पग, या हैंडलबार्स जैसे टेम्पलेटिंग इंजन का उपयोग करके, आप गतिशील HTML उत्पन्न कर सकते हैं।

उदाहरण: view/index.ejs

  
Welcome to My App
  

    
  

परीक्षण
यह सुनिश्चित करने के लिए कि आपका एप्लिकेशन सही ढंग से काम करता है, परीक्षण निर्देशिका में परीक्षण फ़ाइलें शामिल हैं। परीक्षणों को अक्सर इकाई परीक्षण, एकीकरण परीक्षण और एंड-टू-एंड (ई2ई) परीक्षणों में व्यवस्थित किया जाता है।

उदाहरण: निर्देशिका संरचना

tests/
├── unit/
├── integration/
├── e2e/

उपयोग
यूटिलिटी फ़ंक्शंस और हेल्पर मॉड्यूल यूटिल्स डायरेक्टरी में संग्रहीत हैं। ये फ़ंक्शन सत्यापन और फ़ॉर्मेटिंग जैसे सामान्य कार्य करते हैं जिनका उपयोग पूरे एप्लिकेशन में किया जाता है।

उदाहरण: utils/validation.js

exports.isEmailValid = (email) => {
  const re = /^[^\s@] @[^\s@] \.[^\s@] $/;
  return re.test(String(email).toLowerCase());
};

नोड_मॉड्यूल
नोड_मॉड्यूल निर्देशिका में आपके प्रोजेक्ट के लिए आवश्यक सभी निर्भरताएँ शामिल हैं। यह निर्देशिका npm (या यार्न) द्वारा प्रबंधित की जाती है और इसमें npm रजिस्ट्री से स्थापित पैकेज शामिल हैं।

निष्कर्ष
Express.js का उपयोग करके एक अच्छी तरह से संरचित Node.js एप्लिकेशन रखरखाव, स्केलेबिलिटी और सहयोग को बढ़ाता है। संरचना में प्रत्येक निर्देशिका और फ़ाइल कॉन्फ़िगरेशन को संभालने और मार्गों को परिभाषित करने से लेकर मिडलवेयर को प्रबंधित करने और दृश्य प्रस्तुत करने तक एक विशिष्ट उद्देश्य प्रदान करती है। अपने कोडबेस को प्रभावी ढंग से व्यवस्थित करके, आप आसानी से मजबूत और स्केलेबल एप्लिकेशन बना सकते हैं।