पाठ का अंश

इतिहास पढ़ना: log, diff, show और पिछले बदलावों में नेविगेशन

प्रोजेक्ट का इतिहास सिर्फ एक लॉग नहीं है, यह निर्णयों का दस्तावेजीकरण है। हम इतिहास को सार्थक रूप से पढ़ना सीखेंगे: कमिट को फ़िल्टर करना, संस्करणों के बीच वास्तविक अंतर देखना और SHA-1 हैश को बिना किसी डर के समझना। खास तौर पर हम यह समझेंगे कि 'अच्छे इतिहास' और 'बेकार इतिहास' में क्या अंतर है — इसका सीधा असर इस बात पर पड़ता है कि टीम में आपको कैसे देखा जाता है।

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

पाठ की शुरुआत

कमिट का इतिहास प्रोजेक्ट की डायरी के रूप में

  • Git log इतिहास को उलटी डायरी की तरह दिखाता है
  • प्रत्येक प्रविष्टि बदलावों का एक स्नैपशॉट है
  • यह संग्रहीत करता है कि किसने, कब और क्या बदला
  • कोड के विकास को देखने की अनुमति देता है

कल्पना कीजिए कि हर बार जब आप Git में बदलाव सहेजते हैं, तो आप विकास डायरी में एक प्रविष्टि कर रहे हैं। 'git log' कमांड इन प्रविष्टियों को उलटे कालानुक्रमिक क्रम में दिखाता है — सबसे नए से पुराने तक। इस डायरी में प्रोजेक्ट का पूरा कालक्रम संग्रहीत होता है: किसने, कब और कौन से संपादन किए। यह सिर्फ बदलावों की सूची नहीं है, बल्कि आपके कोड के विकास की जीवंत कहानी है। इस इतिहास को पढ़ने और विश्लेषण करने की क्षमता टीम में काम करने के लिए एक महत्वपूर्ण कौशल है। आखिरकार, कमिट के इतिहास के माध्यम से ही आप देखते हैं कि प्रोजेक्ट कैसे विकसित हुआ, क्या निर्णय लिए गए और क्यों। आइए अब एक अलग कमिट की संरचना को विस्तार से देखें।

कमिट रिकॉर्ड पढ़ें: हैश, लेखक, तिथि

  • commit: अद्वितीय हैश पहचानकर्ता
  • Author: किसने और कब परिवर्तन किए
  • Date: कमिट का समय-चिह्न (टाइमस्टैम्प)
  • संदेश: वास्तव में क्या बदला गया

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

#!/bin/bash
cd ~/projects/git-course/
git log -1 --pretty=format:'commit %H%nAuthor: %an <%ae>%nDate:   %ad%n%n    %s'

कमिट हैश — इतिहास की कुंजी

  • हैश कमिट का डिजिटल फिंगरप्रिंट होता है
  • यह सामग्री और मेटाडेटा पर निर्भर करता है
  • एक अक्षर बदलने पर भी हैश पूरी तरह बदल जाता है
  • किसी भी संस्करण को सटीकता से संदर्भित करने की अनुमति देता है

कमिट हैश कोई यादृच्छिक अक्षरों का समूह नहीं है, बल्कि एक क्रिप्टोग्राफिक फ़ंक्शन का परिणाम है जो कमिट की सामग्री को एक अद्वितीय स्ट्रिंग में बदल देता है। अगर कमिट में एक भी बाइट बदल दी जाए, तो हैश पूरी तरह बदल जाता है। यह बदलावों के इतिहास की अखंडता सुनिश्चित करता है। हैश जानकर, आप कोड के किसी भी संस्करण को संदर्भित कर सकते हैं, जैसे किसी किताब में बुकमार्क। उदाहरण के लिए, 'git checkout' कमांड के साथ हैश निर्दिष्ट करने से आप उस कमिट के समय प्रोजेक्ट की स्थिति में पहुँच जाएँगे। यह विशेष रूप से तब उपयोगी होता है जब आपको बदलावों को वापस लाना हो या विश्लेषण करना हो कि बग कब आया। अब जब हम इतिहास की संरचना समझ गए हैं, तो आइए इसे फ़िल्टर करना सीखें - असल प्रोजेक्ट्स जैसे Flipkart या Zomato में हज़ारों कमिट हो सकते हैं।

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

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

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

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

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

  1. कमिट का इतिहास प्रोजेक्ट की डायरी के रूप में
  2. कमिट रिकॉर्ड पढ़ें: हैश, लेखक, तिथि
  3. कमिट हैश — इतिहास की कुंजी
  4. लेखक के कमिट कैसे खोजें
  5. कमिट तिथि के अनुसार फ़िल्टर करना
  6. कमिट संदेशों में खोज
  7. फ़िल्टर का संयोजन
  8. समस्या: कमिट इतिहास पढ़ना
  9. --oneline के साथ संक्षिप्त प्रदर्शन
  10. --graph के साथ शाखाओं का दृश्य
  11. --all के साथ पूरा चित्र
  12. git diff क्या है और इसकी आवश्यकता
  13. कार्यशील निर्देशिका में परिवर्तनों की तुलना
  14. कमिट के लिए तैयार: git diff --staged
  15. किन्हीं दो कमिटों की तुलना करना
  16. किसी विशेष कमिट का विस्तार से अध्ययन कैसे करें
  17. अभ्यास: कमिट में बदलाव देखना
  18. कमिट में किसी विशेष फ़ाइल को देखना
  19. फ़ंक्शन के जोड़ने या हटाने की खोज
  20. इतिहास के ज़रिए दूसरे के कोड का विश्लेषण
  21. फ़ंक्शन के जोड़ने या हटाने की खोज
  22. कमिट संदेश क्यों महत्वपूर्ण हैं
  23. सही कमिट संदेश की संरचना
  24. Conventional Commits व्यवहार में
  25. खराब कमिट का रिफैक्टरिंग
  26. क्यों 'fix' कमिट एक एंटीपैटर्न है
  27. परिवर्तनों की परमाणुता: एक कमिट - एक कार्य
  28. git add -p: स्वच्छ कमिट के लिए जीवन रक्षक उपकरण
  29. निष्कर्ष और कार्य

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

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

  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. अंतिम प्रोजेक्ट: वास्तविक टीम डेवलपमेंट का अनुकरण