मुख्य कंटेंट तक स्किप करें

आर्किटेक्चर विश्लेषण

अपने कोडबेस आर्किटेक्चर को समझने और सुधारने के लिए ArchiCore का उपयोग करना सीखें।

अवलोकन​

ArchiCore आपके कोड संरचना का विश्लेषण करता है ताकि पहचान सके:

  • मॉड्यूल निर्भरताएं
  • चक्रीय निर्भरताएं
  • लेयर उल्लंघन
  • जटिलता हॉटस्पॉट
  • आर्किटेक्चर पैटर्न

विज़ुअलाइज़ेशन​

निर्भरता ग्राफ​

मुख्य डैशबोर्ड एक इंटरैक्टिव निर्भरता ग्राफ दिखाता है:

  • नोड्स फ़ाइलों या मॉड्यूल का प्रतिनिधित्व करते हैं
  • एज इम्पोर्ट/निर्भरताओं का प्रतिनिधित्व करते हैं
  • रंग मॉड्यूल प्रकार या स्वास्थ्य दर्शाते हैं
  • आकार फ़ाइल जटिलता को दर्शाता है

नेविगेशन​

  • ज़ूम माउस व्हील से
  • पैन ड्रैग करके
  • क्लिक नोड्स पर विवरण देखने के लिए
  • डबल-क्लिक मॉड्यूल पर फोकस करने के लिए

आर्किटेक्चर नियम​

आर्किटेक्चरल सीमाओं को लागू करने के लिए नियम परिभाषित करें।

नियम बनाना​

// .archicore/rules.json
{
  "rules": [
    {
      "id": "layer-separation",
      "name": "लेयर अलगाव",
      "type": "import",
      "severity": "error",
      "config": {
        "forbidden": [
          {
            "from": "controllers/*",
            "to": "repositories/*",
            "message": "कंट्रोलर सीधे रिपॉजिटरी एक्सेस नहीं करना चाहिए"
          }
        ]
      }
    }
  ]
}

बिल्ट-इन नियम​

नियमविवरण
no-circular-depsचक्रीय निर्भरताओं को रोकता है
max-complexityसाइक्लोमैटिक जटिलता सीमित करता है
max-file-lengthफ़ाइल आकार सीमित करता है
naming-conventionनामकरण मानक लागू करता है

नियमों की पुष्टि​

> /rules validate
आर्किटेक्चर नियमों की पुष्टि हो रही है...

✓ no-circular-deps: पास
✗ layer-separation: विफल (2 उल्लंघन)
  - src/controllers/user.ts:5 src/repositories/user.ts इम्पोर्ट करता है
  - src/controllers/product.ts:3 src/repositories/product.ts इम्पोर्ट करता है

बाउंडेड कॉन्टेक्स्ट​

अपने एप्लिकेशन में तार्किक सीमाएं परिभाषित करें:

// .archicore/architecture.json
{
  "boundedContexts": [
    {
      "name": "प्रमाणीकरण",
      "description": "उपयोगकर्ता प्रमाणीकरण और सत्र",
      "paths": ["src/auth/*", "src/middleware/auth*"]
    },
    {
      "name": "उत्पाद",
      "description": "उत्पाद कैटलॉग प्रबंधन",
      "paths": ["src/products/*", "src/inventory/*"]
    }
  ]
}

मेट्रिक्स​

जटिलता मेट्रिक्स​

  • साइक्लोमैटिक जटिलता - स्वतंत्र पथों की संख्या
  • संज्ञानात्मक जटिलता - कोड को समझना कितना कठिन है
  • रखरखाव सूचकांक - समग्र रखरखाव स्कोर

हॉटस्पॉट की पहचान​

> /metrics --sort complexity
कोड जटिलता हॉटस्पॉट:

1. src/services/order.ts:processOrder()
   जटिलता: 25 | लाइनें: 180 | रखरखाव: 45

2. src/utils/parser.ts:parseInput()
   जटिलता: 18 | लाइनें: 120 | रखरखाव: 52

3. src/api/handlers.ts:handleRequest()
   जटिलता: 15 | लाइनें: 95 | रखरखाव: 58

रीफैक्टरिंग सुझाव​

ArchiCore रीफैक्टरिंग अवसर सुझा सकता है:

> /refactoring src/services/order.ts
src/services/order.ts के लिए रीफैक्टरिंग सुझाव:

1. मेथड निकालें
   processOrder() बहुत जटिल है (25)
   सुझाव: वैलिडेशन लॉजिक को validateOrder() में निकालें

2. फ़ाइल विभाजित करें
   फ़ाइल में 180 लाइनें हैं जिसमें कई जिम्मेदारियां हैं
   सुझाव: OrderProcessor और OrderValidator में विभाजित करें

3. निर्भरताएं कम करें
   फ़ाइल 12 मॉड्यूल इम्पोर्ट करती है
   सुझाव: कपलिंग कम करने के लिए फेसेड पैटर्न पर विचार करें

सर्वोत्तम प्रथाएं​

  1. नियमित रूप से विश्लेषण चलाएं - समस्याओं को जल्दी पकड़ें
  2. आर्किटेक्चर नियम परिभाषित करें - उल्लंघन रोकें
  3. जटिलता की समीक्षा करें - हॉटस्पॉट रीफैक्टर करें
  4. ट्रेंड मॉनिटर करें - समय के साथ मेट्रिक्स ट्रैक करें