Git Reflog: Git में रेफरेंस लॉग को समझें और उपयोग करें

डेवलपर या डेटा इंजीनियर के लिए इससे ज्यादा परेशान करने वाली बात नहीं होती जब गलती से किसी git ब्रांच को डिलीट कर दिया जाए या कमिट्स रीसेट हो जाएँ। इसलिए मैं अपने अनुभव से सीखी एक चीज़—git reflog—आपके साथ साझा करने के लिए उत्साहित हूँ। git reflog ऐसी तकनीक है जिसे सीखना वाकई फायदेमंद है; अभी थोड़ा समय लगाएंगे, तो आगे चलकर बड़े सिरदर्द से बच सकते हैं। 

मैं यहाँ git reflog दिखाऊँगा, जो गलतियों से उबरने और नेविगेट करने में बहुत मददगार है, साथ ही मैं आपको हमारे Foundations of Git और Introduction to GitHub Concepts कोर्स भी सुझाऊँगा ताकि आप वर्ज़न कंट्रोल के बारे में हर जरूरी बात सीख सकें।

git reflog क्या है?

Git reflog, या रेफरेंस लॉग, एक लोकल ट्रैकिंग मैकेनिज़्म है जो Git रिपॉज़िटरी में ब्रांच टिप्स और HEAD रेफरेंस में हुए अपडेट्स को रिकॉर्ड करता है। (Git के संदर्भ में, HEAD उस करंट कमिट को संदर्भित करता है जिस पर आपका वर्किंग डायरेक्टरी और स्टेजिंग एरिया आधारित होता है।)

git log के विपरीत, जो ब्रांच में कमिट्स की वंशावली के आधार पर हिस्ट्री दिखाता है, git reflog HEAD की हर मूवमेंट को कैप्चर करता है—जैसे ब्रांच स्विच, रिबेस, रिसेट्स और कमिट्स। यही कारण है कि reflog खोए हुए कमिट्स को रिकवर करने और हाल की कार्रवाइयों को डिबग करने में उपयोगी है।

reflog एंट्री कब बनती हैं?

जब भी आप ऐसी कार्रवाई करते हैं जो HEAD या ब्रांच रेफरेंस की स्थिति बदलती है, reflog एंट्री बनती हैं। आम परिदृश्य इस प्रकार हैं:

• git commit का उपयोग कर बदलाव कमिट करना।

• git checkout branch_name के साथ किसी दूसरी ब्रांच पर जाना।

• git branch new_branch से नई ब्रांच बनाना।

• रिबेस करना git rebase

• पिछले कमिट पर रिसेट करना git reset --hard।

• ब्रांचेस को मर्ज करना git merge से।

लोकल रिपॉज़िटरी में अपडेट्स ट्रैक करने के लिए यह कमांड उपयोग करें:

git reflog

लोकल रिपॉज़िटरी में अपडेट्स ट्रैक करने के लिए git reflog का उपयोग। इमेज: लेखक।

git reflog के आउटपुट की व्याख्या कैसे करें?

आप आउटपुट को इस प्रकार समझ सकते हैं:

• HEAD@{0}: सबसे हाल की कार्रवाई में HEAD ब्रांच पर स्विच किया गया था।

• HEAD@{1}: उससे पहले, मैंने एक फ़ाइल प्रकार .xlxs से .csv फॉर्मेट में बदला था।

• HEAD@{2}: मैंने रिपॉज़िटरी में फाइलें पुश करते समय पहला कमिट किया था।

हर एंट्री में दिखता है:

• कमिट हैश (fa82776)

• reflog इंडेक्स (HEAD@{0}, HEAD@{1}, आदि)

• की गई कार्रवाई का विवरण (commit, checkout, rebase)

git reflog का उपयोग कैसे करें

Git reflog रेफरेंस अपडेट्स को ट्रैक करने और आपकी रिपॉज़िटरी की पूर्व अवस्थाओं को पुनर्स्थापित करने का तरीका देता है। reflog एंट्रीज़ को समझकर आप खोए हुए कमिट्स रिकवर कर सकते हैं, बदलाव वापस ले सकते हैं, और अपने काम के पुराने संस्करणों की तुलना कर सकते हैं। 

बेसिक git reflog कमांड

नीचे बेसिक reflog कमांड है:

git reflog

ऊपर का कमांड HEAD या ब्रांच रेफरेंस को अपडेट करने वाली हाल की कार्रवाइयों की सूची दिखाता है, जिसमें कमिट्स, ब्रांच स्विच, रिसेट्स, रिबेस आदि शामिल हैं। प्रत्येक एंट्री इंडेक्स्ड होती है, जैसे HEAD@{0} और HEAD@{1}, जो reflog हिस्ट्री में उसकी स्थिति दर्शाता है।

पुरानी अवस्थाओं का संदर्भ लेना

Git reflog पिछले रेफरेंस अपडेट्स का रिकॉर्ड है, जो हमें अपनी रिपॉज़िटरी की हिस्ट्री में पुराने बिंदु खोजने और पुनर्स्थापित करने देता है। इसके बिना ये रेफरेंसेज़ मौजूद नहीं होते, और हमें किसी विशेष पुरानी अवस्था पर लौटने के लिए सटीक कमिट हैश चाहिए होता। अब देखें कि Git git checkout के ज़रिये हमें इन पुरानी अवस्थाओं में नेविगेट करने में कैसे सक्षम बनाता है।

HEAD@{n}: किसी विशेष reflog एंट्री को संदर्भित करता है, जहाँ n इंडेक्स है। उदाहरण के लिए, HEAD@{2} HEAD की तीसरी सबसे हाल की अवस्था को दर्शाता है।

git checkout HEAD@{2}

पुराने बदलावों को ट्रैक करने के लिए git checkout का उपयोग। इमेज: लेखक।

branch@{time}: किसी ब्रांच की एक विशेष समय पर स्थिति को संदर्भित करता है। उदाहरण के लिए, main@{1.week.ago} मुख्य ब्रांच की एक सप्ताह पहले की स्थिति को दर्शाता है, जबकि feature@{yesterday} फीचर ब्रांच की कल की स्थिति को दर्शाता है।

git checkout main@{1.week.ago}

पुराने बदलावों को ट्रैक करने के लिए git checkout का उपयोग। इमेज: लेखक।

समय-आधारित क्वालिफ़ायर्स

git reflog न केवल हमें पुरानी अवस्थाएँ बहाल करने में मदद करता है, बल्कि उनकी तुलना करने देता है। चूँकि reflog रेफरेंस अपडेट्स को ट्रैक करता है, हम देख सकते हैं कि समय के साथ रिपॉज़िटरी कैसे बदली। अब देखें कि git diff कैसे पिछली और वर्तमान अवस्थाओं की तुलना के लिए reflog एंट्रीज़ का उपयोग करता है।

नीचे समय-आधारित क्वालिफ़ायर्स के उदाहरण हैं, जो केवल reflog इंडेक्स नंबरों पर निर्भर रहने के बजाय किसी खास समय बिंदु पर रिपॉज़िटरी बहाल करना आसान बनाते हैं।

git checkout HEAD@{1.minute.ago}     # एक मिनट पहले की स्थिति

git checkout HEAD@{1.hour.ago}       # एक घंटे पहले की स्थिति

git checkout HEAD@{1.week.ago}       # एक सप्ताह पहले की स्थिति

git checkout HEAD@{yesterday}        # कल की स्थिति

git checkout HEAD@{2024-01-01.12:00:00} # एक विशिष्ट टाइमस्टैम्प पर स्थिति

git diff से पुरानी अवस्थाओं की तुलना

आप git diff जैसे कमांड से पुरानी अवस्थाओं की तुलना कर सकते हैं। निम्न कमांड मुख्य ब्रांच की वर्तमान स्थिति main@{0} की तुलना एक दिन पहले की स्थिति main@{1.day.ago} से करता है। आउटपुट इन दोनों स्नैपशॉट्स के बीच के फर्क दिखाएगा।

git diff main@{0} main@{1.day.ago}

git diff से पुरानी अवस्थाओं की तुलना। इमेज: लेखक।

Git Reflog के सामान्य उपयोग

Git reflog खोए हुए बदलावों को रिकवर करने, गलतियाँ वापस लेने और आम Git गड़बड़ियों को ठीक करने का अमूल्य टूल है। नीचे कुछ व्यावहारिक स्थितियाँ हैं जहाँ git reflog मदद कर सकता है।

गलत reset को वापस लेना

यदि आपने गलती से git reset --hard से अपनी ब्रांच रिसेट कर दी है, तो आप reflog की मदद से पिछली स्थिति बहाल कर सकते हैं।

git reset --hard HEAD@{3}

खोए हुए कमिट्स रिकवर करना

अगर आपने गलती से कोई ब्रांच डिलीट कर दी या reset/rebase के कारण कमिट्स खो गए, तो आप git reflog से वह कमिट ढूँढ सकते हैं।

git reflog

reflog आउटपुट से कमिट हैश खोजें और उसे चेकआउट करें:

git checkout <commit-hash>

लॉस्ट कमिट वेरिफ़ाई करने के बाद, उसे सुरक्षित रखने के लिए नई ब्रांच बनाएँ:

git branch recovered-branch <commit-hash>

खराब rebase को ठीक करना

यदि rebase गलत हो जाए, तो आप git reflog से pre-rebase कमिट ढूँढकर अपनी ब्रांच रिसेट कर सकते हैं। रिबेस से पहले वाला कमिट पहचानें और रिसेट करें।

git reset --hard HEAD@{3}  # reflog आउटपुट के आधार पर संख्या समायोजित करें

डिलीट की गई ब्रांच बहाल करना

यदि आपने गलती से कोई ब्रांच डिलीट कर दी, तो git reflog से उसे रिकवर कर सकते हैं। डिलीटेड ब्रांच के आखिरी ज्ञात कमिट को ढूँढें और उसे फिर से बनाएँ:

git branch restored-branch <commit-hash>

स्टैश हिस्ट्री ट्रैक करना

Git reflog का उपयोग स्टैश हिस्ट्री देखने के लिए भी किया जा सकता है। नीचे दिया कमांड स्टैश ऑपरेशंस की सूची देता है, जिससे ज़रूरत पड़ने पर पुराने स्टैश रिकवर किए जा सकते हैं। 

git reflog stash

किसी पुराने स्टैश एंट्री को अप्लाई करने के लिए यह कमांड उपयोग करें:

git stash apply stash@{2}

लोकल बदलावों को ओवरराइट करने के सर्वोत्तम तरीकों को सीखने के लिए हमारा Git Pull Force: How to Overwrite a Local Branch With Remote ट्यूटोरियल देखें।

Git Reflog उप-कमांड्स और ऑप्शंस

Git, reflog को प्रबंधित करने और उससे इंटरैक्ट करने के लिए कई उप-कमांड्स और विकल्प प्रदान करता है। 

Git reflog उप-कमांड्स

नीचे प्रमुख git reflog उप-कमांड्स और उनके उपयोग का संरचित विवरण है।

git reflog show: डिफॉल्ट रूप से HEAD के लिए, या किसी निर्दिष्ट रेफरेंस जैसे ब्रांच के लिए, reflog एंट्रीज़ दिखाता है।

git reflog show

निर्दिष्ट रेफरेंस की एंट्रीज़ दिखाने के लिए git reflog show का उपयोग। इमेज: लेखक।

git reflog list: यह कमांड उन सभी रेफरेंसेज़ को दिखाता है जिनका reflog मौजूद है। यह उन ब्रांचेस और HEAD रेफरेंसेज़ की पहचान करने में उपयोगी है जिनकी reflog एंट्रीज़ स्टोर हैं।

git reflog list

git reflog delete <ref>@{<specifier>}: निर्धारित समय-सीमा से अधिक पुरानी reflog एंट्रीज़ को क्लीन करता है। उदाहरण के लिए, नीचे दिया कमांड 30 दिनों से पुरानी एंट्रीज़ हटा देता है।

git reflog expire --expire=30.days.ago

git reflog delete <ref>@{<specifier>}: किसी विशेष रेफरेंस और उसकी स्थिति के आधार पर एक खास reflog एंट्री डिलीट करता है। नीचे दिया कमांड HEAD के लिए इंडेक्स 2 पर मौजूद reflog एंट्री हटाता है।

git reflog delete HEAD@{2}

git reflog exists <ref>: यह सत्यापित करता है कि किसी विशेष रेफरेंस के लिए reflog मौजूद है या नहीं। उदाहरण के लिए, नीचे दिया कमांड सफलता लौटाएगा यदि main ब्रांच का reflog है।

git reflog exists main

git reflog उप-कमांड्स के विकल्प

नीचे git reflog उप-कमांड्स के उपलब्ध विकल्प और उनका उपयोग दिए गए हैं।

--expire-unreachable=<time>: केवल वे reflog एंट्रीज़ प्रून करता है जो किसी भी रेफरेंस से अप्राप्य हैं। उदाहरण: नीचे का कमांड 7 दिनों से पुरानी अप्राप्य एंट्रीज़ हटाता है।

git reflog expire --expire-unreachable=7.days.ago

--all: केवल HEAD ही नहीं, बल्कि सभी रेफरेंसेज़ के reflog प्रोसेस करता है। नीचे दिया कमांड सभी ब्रांचेस में 60 दिनों से पुराने सभी reflog एंट्रीज़ क्लीन करता है।

git reflog expire --expire=60.days.ago --all

--dry-run: कमांड को सिमुलेट करता है, यह दिखाते हुए कि क्या प्रून होगा, बिना वास्तव में कुछ डिलीट किए। उदाहरण: नीचे का कमांड दिखाएगा कि कौन-सी एंट्रीज़ हटेंगी।

git reflog expire --expire=30.days.ago --dry-run

--verbose: कमांड द्वारा किए गए कार्यों के बारे में विस्तृत आउटपुट देता है। नीचे का कमांड पुरानी reflog एंट्रीज़ को expire करते समय विस्तृत विवरण दिखाता है।

git reflog expire --expire=90.days.ago --verbose

Git Reflog बनाम Git Log: प्रमुख अंतर

git log और git reflog दोनों रिपॉज़िटरी की हिस्ट्री पर प्रकाश डालते हैं, लेकिन उनके उद्देश्य अलग हैं। आइए इन अंतरों को देखें ताकि समझ सकें कि वर्ज़न कंट्रोल और रिकवरी रणनीतियों में प्रत्येक का उपयोग कैसे करें।

• git log ब्रांच में कमिट्स की वंशावली का अनुसरण करके कमिट हिस्ट्री दिखाता है। यह दिखाता है कि रिपॉज़िटरी की सामग्री समय के साथ कैसे विकसित हुई।

• git reflog HEAD, ब्रांचेस और स्टैश जैसे रेफरेंसेज़ में हुए अपडेट्स रिकॉर्ड करता है, जिनमें ब्रांच स्विच, रिसेट, रिबेस आदि क्रियाएँ शामिल हैं। यह उन बदलावों को भी ट्रैक करता है जो कमिट वंशावली का हिस्सा नहीं होते।

• git reflog सख्ती से आपके लोकल मशीन तक सीमित होता है और रिमोट रिपॉज़िटरीज़ के साथ साझा नहीं होता।

• जहाँ git log उन कमिट्स को रिकवर नहीं कर सकता जो अब ब्रांच वंशावली का हिस्सा नहीं हैं, वहीं git reflog रेफरेंस अपडेट्स को ट्रैक करके "खोए हुए" कमिट्स रिकवर करने में मदद कर सकता है, भले ही वे कमिट्स किसी ब्रांच से अब पहुँच योग्य न हों।

नीचे दी गई तालिका इन प्रमुख अंतरों का सार प्रस्तुत करती है।

Git reflog खोए हुए कमिट्स रिकवर करने और हिस्ट्री से जुड़ी समस्याएँ ठीक करने का शक्तिशाली टूल है, लेकिन इसे प्रभावी ढंग से उपयोग करने के लिए सावधानी आवश्यक है। reflog के साथ काम करते समय ये सर्वोत्तम अभ्यास अपनाएँ।

• रिकवरी और डिबगिंग के लिए Reflog का उपयोग करें: यदि आपने गलती से reset या rebase गलत किया है, तो git reflog देखें, पिछला रेफरेंस खोजें और उसे बहाल करें।

• git reset --hard का सावधानी से उपयोग करें: git reset --hard बिना कमिट किए गए बदलावों को स्थायी रूप से हटा सकता है। हमेशा पहले reflog जाँचें ताकि गड़बड़ी होने पर रिकवर कर सकें।

• विनाशकारी कमांड चलाने से पहले बैकअप रखें: डेटा लॉस से बचाव के लिए अपनी Git रिपॉज़िटरीज़ के ऑटोमेटेड बैकअप लागू करें। बैकअप हमेशा सुरक्षित, ऑफ-साइट स्थान पर रखें ताकि हार्डवेयर फेल्योर या अन्य आपदाओं की स्थिति में रिकवरी संभव हो।

• लॉन्ग-टर्म रिकवरी के लिए केवल Reflog पर निर्भर न रहें: डिफॉल्ट रूप से, reflog एंट्रीज़ 90 दिनों तक रखी जाती हैं। इस अवधि के बाद वे गार्बेज कलेक्ट होकर अपुनर्प्राप्य हो सकती हैं। अपने कमिट्स को नियमित रूप से रिमोट रिपॉज़िटरी पर पुश करें ताकि वे लोकल reflog से आगे भी संरक्षित रहें।

• पुरानी एंट्रीज़ मैनेज करने के लिए git reflog expire का उपयोग करें: यदि आपकी रिपॉज़िटरी का reflog भरा हुआ है, तो git reflog expire से पुरानी या अप्राप्य एंट्रीज़ प्रून करें।

निष्कर्ष

Git में किसी प्रोजेक्ट की हिस्ट्री को प्रभावी ढंग से मैनेज करना सिर्फ बेसिक कमांड्स से आगे की चीज़ है। रेफरेंस अपडेट्स को ट्रैक करने वाले उन्नत टूल्स का उपयोग खोए हुए कमिट्स रिकवर करने, डिलीटेड ब्रांचेस बहाल करने और गलतियाँ सुधारने के लिए सुरक्षा-जाल देता है। इन टूल्स के साथ हाथों-हाथ अनुभव, और git reset, git checkout, तथा git revert जैसे कमांड्स के साथ, आपके वर्ज़न कंट्रोल कौशल को काफी बढ़ा सकता है।

हमारे कोर्स करना सीखने का बेहतरीन तरीका ही नहीं, बल्कि नियोक्ताओं को यह संकेत देने का भी अच्छा तरीका है कि आप सॉफ़्टवेयर डेवलपमेंट को गंभीरता से लेते हैं. इसी क्रम में, मैं हमारे Top 20 Git Interview Questions and Answers for All Levels ब्लॉग पोस्ट का अध्ययन करने और हमारे नए Git Fundamentals स्किल ट्रैक को लेने की सिफारिश करता हूँ, ताकि आप Git से जुड़ी हर चीज़ में विशेषज्ञ बन सकें।