पाठ का अंश

अंतिम प्रोजेक्ट: वास्तविक टीम डेवलपमेंट का अनुकरण

आपने जो कुछ भी सीखा है, उसे एक जुड़े हुए परिदृश्य में लागू करें: आप एक छोटी टीम में डेवलपर हैं, जिसे एक नई सुविधा जोड़नी है, एक बग ठीक करना है और एक रिलीज़ जारी करनी है। चरण-दर-चरण पूरे चक्र को पूरा करें: रिपॉजिटरी बनाना, शाखाओं में काम करना, पुल रिक्वेस्ट, जानबूझकर बनाए गए विरोधाभास और उनका समाधान, इतिहास को साफ करने के लिए रीबेस और अंतिम रिलीज़ टैग। अंत में, आपके पास एक वास्तविक रिपॉजिटरी होगी जिसे आप नियोक्ता को दिखा सकते हैं।

पूर्ण Git-वर्कफ़्लो टीम डेवलपमेंट रिलीज़ चक्र
इस पाठ में आप क्या सीखेंगे
  • आप Git में एक सुविधा के पूर्ण विकास चक्र को स्वयं संचालित करने में सक्षम होंगे - शाखा बनाने से लेकर main में मर्ज करने तक।
  • आप समझेंगे कि एक टीम में वास्तविक कार्यप्रवाह कैसा दिखता है, और पहले कार्य दिवस से इसके लिए तैयार रहेंगे।
  • आपको एक तैयार रिपॉजिटरी मिलेगी जिसमें सार्थक कमिट इतिहास होगा, जिसे आप पोर्टफोलियो में जोड़ सकते हैं और साक्षात्कार में दिखा सकते हैं।

पाठ की शुरुआत

पोर्टफोलियो के लिए रिपॉजिटरी आरंभ करें

  • प्रोजेक्ट के लिए नया फ़ोल्डर बनाएँ
  • खाली Git रिपॉजिटरी आरंभ करें
  • अनावश्यक फ़ाइलों को बाहर करने के लिए .gitignore जोड़ें
  • कार्यशील निर्देशिका की स्थिति जाँचें

टर्मिनल खोलें और प्रोजेक्ट के लिए एक नया फ़ोल्डर बनाएँ: mkdir portfolio-project। उसमें जाएँ और git init चलाएँ - यह एक छिपा हुआ फ़ोल्डर .git बनाएगा, जहाँ Git सभी परिवर्तन इतिहास संग्रहीत करेगा। अब .gitignore फ़ाइल जोड़ें जिसमें node_modules/ और .env हो, ताकि निर्भरता और गोपनीय डेटा को संस्करण नियंत्रण से बाहर रखा जा सके। git status कमांड से वर्तमान स्थिति जाँचें - आपको अपरिवर्तित फ़ाइलों की सूची में नई फ़ाइल दिखनी चाहिए। यह नींव है जिस पर आपका पेशेवर प्रोजेक्ट शुरू होगा। सुनिश्चित करें कि सभी फ़ाइलें सही ढंग से बनाई गई हैं और सही स्थानों पर हैं।

#!/bin/bash
# प्रोजेक्ट फ़ोल्डर बनाएँ
mkdir portfolio-project

# प्रोजेक्ट फ़ोल्डर में जाएँ
cd portfolio-project

# Git रिपॉजिटरी आरंभ करें
git init

# .gitignore फ़ाइल बनाएँ
cat > .gitignore << EOL
node_modules/
.env
EOL

# रिपॉजिटरी की स्थिति जाँचें
git status

प्रोजेक्ट को मानकों के अनुसार संरचित करें

  • मानक फ़ोल्डर बनाएँ: src, docs, tests
  • प्रोजेक्ट विवरण के साथ README जोड़ें
  • सभी परिवर्तनों को कमिट के लिए तैयार करें
  • फिक्सेशन से पहले स्थिति जाँचें

क्लीन प्रोजेक्ट स्ट्रक्चर एक साफ-सुथरे डेस्क की तरह है: सब कुछ अपनी जगह पर। तीन मुख्य फ़ोल्डर बनाएँ: src (स्रोत कोड), docs (दस्तावेज़ीकरण), और tests (परीक्षण)। README.md फ़ाइल जोड़ें जिसमें प्रोजेक्ट का संक्षिप्त विवरण हो। अब git add . चलाएँ ताकि सभी फ़ाइलें स्टेजिंग एरिया में आ जाएँ। फिर से git status जाँचें - अब सभी नई फ़ाइलें कमिट के लिए तैयार परिवर्तनों की सूची में होनी चाहिए। यह पेशेवर कोड बेस संगठन की दिशा में पहला कदम है। सुनिश्चित करें कि संरचना उद्योग मानकों के अनुरूप हो।

#!/bin/bash
# मानक फ़ोल्डर बनाएँ
mkdir src docs tests

# विवरण के साथ README बनाएँ
cat > README.md << EOL
# Portfolio Project

यह प्रोजेक्ट Git के साथ काम करने के कौशल को प्रदर्शित करता है।
EOL

# सभी फ़ाइलों को स्टेजिंग एरिया में जोड़ें
git add .

# रिपॉजिटरी की स्थिति जाँचें
git status

पहला अर्थपूर्ण कमिट

  • समझदारी से संदेश देते हुए पहला कमिट बनाएं
  • सेवा संबंधी बदलावों के लिए 'chore' उपसर्ग का उपयोग करें
  • कमिट इतिहास की जाँच करें
  • सुनिश्चित करें कि सभी बदलाव रिकॉर्ड हो गए हैं

अब समय आ गया है प्रोजेक्ट की प्रारंभिक स्थिति को रिकॉर्ड करने का। गिट कमिट -एम 'chore: प्रोजेक्ट संरचना आरंभ करें' लिखें। ध्यान दें कि 'chore' उपसर्ग सेवा संबंधी बदलावों को दर्शाता है। कमिट के बाद गिट लॉग चलाएँ — आप अपना पहला कमिट देखेंगे जिसमें हैश, लेखक और संदेश होगा। यह वह आधार है जिस पर पूरा बदलाव इतिहास निर्मित होगा। एक अच्छा पहला कमिट किसी कलाकार के लिए साफ कैनवास जैसा होता है। सुनिश्चित करें कि संदेश स्पष्ट और जानकारीपूर्ण हो।

#!/bin/bash
# पहला कमिट बनाएं
git commit -m 'chore: प्रोजेक्ट संरचना आरंभ करें'

# कमिट इतिहास जाँचें
git log --oneline

पूरा पाठ सदस्यता के साथ उपलब्ध है

पूर्ण संस्करण में 31 और स्लाइड्स हैं।

वीडियो, सभी स्लाइड्स, नोट्स, टेस्ट, AI ट्यूटर और इंटरव्यू लॉगिन करने और सदस्यता लेने के बाद खुलेंगे।

लॉग इन या रजिस्टर करें सदस्यता लें

पाठ की सामग्री सूची

  1. पोर्टफोलियो के लिए रिपॉजिटरी आरंभ करें
  2. प्रोजेक्ट को मानकों के अनुसार संरचित करें
  3. पहला अर्थपूर्ण कमिट
  4. GitHub पर प्रोजेक्ट प्रकाशित करना
  5. नई सुविधा शुरू करना: शाखा बनाना
  6. एटॉमिक कमिट्स: बदलावों का इतिहास लिखें
  7. विलय से पहले जाँच
  8. पुल रिक्वेस्ट की तैयारी
  9. फाइनल प्रोजेक्ट को रिव्यू के लिए तैयार करना
  10. GitHub पर pull request बनाना
  11. समीक्षा की टिप्पणियों पर काम करना
  12. समीक्षा प्रक्रिया पूरी करना
  13. प्रोडक्शन में तत्काल बग: क्या करें?
  14. हॉटफिक्स ब्रांच सही तरीके से बनाना
  15. त्वरित सुधार और जाँच
  16. आपातकालीन मर्ज और डिप्लॉय
  17. विलय से पहले फीचर ब्रांच को अपडेट करना
  18. कोड में विरोध को हल करना
  19. Rebase और पुश पूरा करना
  20. मर्ज से पहले rebase क्यों जरूरी है?
  21. इंटरएक्टिव rebase का कार्यान्वयन
  22. अंतिम: साफ इतिहास के साथ मर्ज
  23. तैयार फीचर प्रकाशित करना
  24. Squash and Merge के माध्यम से परिवर्तनों का विलय
  25. विलय के बाद सफाई
  26. अंतिम परिणाम और साक्षात्कार में क्या दिखाएँ
  27. रिलीज़ की तैयारी: कोड की तत्परता जाँचें
  28. संस्करण टैग v1.0.0 बनाएँ
  29. GitHub पर रिलीज़ प्रकाशित करें
  30. परिणाम जाँचें और विकास की तैयारी करें
  31. प्रोजेक्ट इतिहास का विश्लेषण
  32. कमिट की पठनीयता का मूल्यांकन
  33. कमिट हिस्ट्री एक पोर्टफोलियो के रूप में
  34. अंतिम समाप्ति: आपका पहला रिलीज़ तैयार है!

इस व्याख्यान से जुड़े लेख

इस कोर्स के सभी पाठ

  1. परिचय: शुरुआत से आत्मविश्वासी डेवलपर तक Git
  2. गिट की आवश्यकता क्यों है — और इसके बिना नौकरी क्यों नहीं मिलती
  3. Git की स्थापना और प्रारंभिक सेटअप: पहली बार चलाने की तैयारी
  4. पहला रिपॉजिटरी: git init, git add, git commit और इंडेक्स का जादू
  5. इतिहास पढ़ना: log, diff, show और पिछले बदलावों में नेविगेशन
  6. शाखाएँ: आपके कोड की समानांतर दुनिया
  7. गलतियाँ सुधारना: restore, reset, revert — सही और खतरनाक तरीके
  8. GitHub और दूरस्थ भंडार: आपका कोड क्लाउड में
  9. टीम वर्क: फ़ोर्क, फ़ीचर ब्रांच और पुल रिक्वेस्ट
  10. मर्ज संघर्ष: घबराएं नहीं — समझें और हल करें
  11. वास्तविक टीमों में Git प्रक्रियाएँ: कौन सा वर्कफ़्लो चुनें
  12. उन्नत उपकरण: rebase, stash, cherry-pick और टैग
  13. अंतिम प्रोजेक्ट: वास्तविक टीम डेवलपमेंट का अनुकरण