अपने प्रोजेक्ट को बिना तोड़े Git रिपॉजिटरी से फ़ाइलें कैसे हटाएँ

Git में फ़ाइलें हटाना हमेशा उतना आसान नहीं होता जितना लगता है। आप अपने सिस्टम से किसी फ़ाइल को डिलीट करते हैं, पर इसका मतलब यह नहीं कि वह रिपॉजिटरी से भी गायब हो गई। वह अभी भी आपके इतिहास में मौजूद हो सकती है, या और भी बुरा, गलती से कमिट हो सकती है—जैसे कोई कॉन्फ़िग फ़ाइल या API कुंजी।

इस गाइड में, आप सीखेंगे कि Git से फ़ाइलें कैसे हटाएँ। हम git rm जैसे बुनियादी कमांड से शुरू करेंगे, फिर अनट्रैक्ड फ़ाइलें साफ़ करने और अपने कमिट इतिहास को एडिट करने जैसी उन्नत विधियों तक जाएँगे।

पूर्वापेक्षाएँ

Git के साथ फ़ाइलें हटाने से पहले, सुनिश्चित कर लें कि सब सेट है।

पहले, जाँच लें कि Git इंस्टॉल है। अपना टर्मिनल खोलें और चलाएँ:

git --version

अगर आप वर्ज़न नंबर देखते हैं, तो सब ठीक है। 

अगर आप वर्ज़न नंबर देखते हैं, तो सब ठीक है।

अगर आप विज़ुअल इंटरफ़ेस पसंद करते हैं, तो GitHub Desktop, Sourcetree, या GitKraken जैसा कोई Git GUI भी इंस्टॉल कर सकते हैं। लेकिन इस गाइड में, मैं कमांड लाइन (Git Bash) का उपयोग करूँगा।

सुनिश्चित करें कि आपके पास रिपॉजिटरी में बदलाव करने की अनुमति है, खासकर अगर आप किसी टीम का हिस्सा हैं या GitHub या GitLab जैसे रिमोट रिपो के साथ काम कर रहे हैं।

नोट: कुछ फ़ाइल हटाने की क्रियाएँ वापस नहीं लाई जा सकतीं। इसलिए, कोई भी डिलीट करने वाला कमांड चलाने से पहले अपने प्रोजेक्ट का बैकअप लेना या कम से कम अपने रिपो की स्थिति को दोबारा जाँचना अच्छा विचार है।

एक बार सब हो जाए, चलिए शुरू करते हैं।

Git में बुनियादी फ़ाइल हटाना

Git में फ़ाइलें हटाने के कई तरीके हैं, यह इस पर निर्भर करता है कि आप क्या करना चाहते हैं। आइए कुछ सामान्य विकल्प देखें:

git rm का उपयोग

git rm कमांड आपकी Git रिपॉजिटरी से फ़ाइलें हटाता है। इसे चलाने पर दो चीज़ें होती हैं:

• Git आपकी वर्किंग डायरेक्टरी से फ़ाइल हटाता है
• यह बदलाव अगले कमिट के लिए स्टेज हो जाता है

लेकिन Git सिर्फ फ़ाइल डिलीट नहीं करता। वह इस डिलीशन को आपके इतिहास में ट्रैक भी करता है। एक बार आप कमिट कर दें, तो फ़ाइल आधिकारिक तौर पर प्रोजेक्ट से हटा दी जाती है।

git rm file1.txt

आप एक फ़ाइल, कई फ़ाइलें, या वाइल्डकार्ड का उपयोग करके फ़ाइलों के समूह को हटा सकते हैं। 

उदाहरण के लिए, सभी लॉग फ़ाइलें हटाने के लिए:

git rm *.log

यह Git को बताता है कि फ़ोल्डर में हर वह फ़ाइल हटाएँ जो .log पर खत्म होती है। आप इसे कन्फर्म करने के लिए चला सकते हैं:

git status

एक git rm कमांड से कई फ़ाइलें हटाएँ। छवि: लेखक।

किसी फ़ोल्डर के अंदर की सारी फ़ाइलें हटाना चाहते हैं, लेकिन फ़ोल्डर नहीं? यह उपयोग करें:

git rm temp/*

यह temp फ़ोल्डर के अंदर की हर फ़ाइल डिलीट कर देता है, बिना फ़ोल्डर को हटाए।

Git कुछ सेफ़्टी चेक भी जोड़ता है। अगर किसी फ़ाइल में अनकमीटेड बदलाव हैं, तो Git उसे तब तक डिलीट नहीं करेगा जब तक आप फोर्स न करें। इसलिए इसे तभी उपयोग करें जब आप सुनिश्चित हों कि वे बदलाव त्यागे जा सकते हैं:

git rm -f

किसी पूरे फ़ोल्डर और उसके अंदर की हर चीज़ हटाने के लिए, -r फ़्लैग जोड़ें:

git rm -r testfolder

यह testfolder और उसके अंदर की सभी फ़ाइलें हटा देता है।

अब, बदलाव को कमिट करने के लिए निम्न कमांड चलाएँ:

git commit -m "removed log files”

महत्वपूर्ण git rm विकल्प

यह रहे वे सबसे सामान्य विकल्प जो आप git rm के साथ उपयोग करेंगे:

1. <filename>

यह बेसिक उपयोग है। बस वे फ़ाइलें लिखें जिन्हें आप हटाना चाहते हैं:

git rm file1.txt file2.txt

आप समान प्रकार की कई फ़ाइलें हटाने के लिए वाइल्डकार्ड भी उपयोग कर सकते हैं। उदाहरण के लिए, सभी .txt फ़ाइलें हटाने के लिए:

git rm *.txt

(यहाँ * का मतलब सभी है। यह किसी भी ऐसे फ़ाइलनाम से मेल खाता है जो .txt पर समाप्त होता है।)

2. --cached

यह फ़ाइल को रिपॉजिटरी से हटाता है लेकिन आपके कंप्यूटर पर रहने देता है। मान लें कि मैंने गलती से config.env जैसी संवेदनशील फ़ाइल जोड़ दी। मैं उसे रिपो में नहीं रखना चाहता, पर मुझे वह अपनी मशीन पर चाहिए। तो मैं चलाऊँगा:

git rm --cached config.env

यहाँ, git rm उसे रिपॉजिटरी और वर्किंग डायरेक्टरी से डिलीट करेगा। और --cached उसे Git से अनट्रैक कर देता है (ताकि वह पुश न हो), पर फ़िजिकल रूप से वहीं रहने देता है।

उसे दोबारा ऐड होने से रोकने के लिए, उसे .gitignore में जोड़ें:

echo config.env >> .gitignore

3. -r

यह recursive के लिए है। एक फ़ाइल की बजाय, यह डायरेक्टरी और उसकी सामग्री को रीकर्सिवली डिलीट करता है। इसके बिना, अगर आप कोई फ़ोल्डर हटाने की कोशिश करेंगे तो Git त्रुटि देगा।

git rm -r <folder-name>

यहाँ, मैंने testfolder नाम का फ़ोल्डर बनाया और उसके अंदर दो फ़ाइलें: a.txt और b.txt. फिर मैंने यह कमांड चलाई:

git rm -r testfolder

इसने फ़ोल्डर को उसकी सारी सामग्री और फ़ाइलों सहित हटा दिया

4. --dry-run

अगर आपको यकीन नहीं कि फ़ाइल हटाने पर क्या होगा, तो git rm को --dry-run विकल्प के साथ ऐसे उपयोग करें:

git rm --dry-run <filename>

यह हटाई जाने वाली चीज़ों का सुरक्षित पूर्वावलोकन देता है। 

या अगर आप अनट्रैक्ड फ़ाइलें साफ़ कर रहे हैं और दोबारा जाँचना चाहते हैं कि क्या हटेगा, तो यह उपयोग करें:

git clean -n

यह केवल दिखाएगा कि यह कमांड क्या डिलीट करेगा।

तुलनात्मक वर्कफ़्लो विश्लेषण

Git में फ़ाइल हटाने का एक से अधिक तरीका है। तरीके दिखने में एक जैसे लग सकते हैं, पर उनका व्यवहार अलग होता है।

git rm बनाम मैनुअल डिलीशन

मान लें एक फ़ाइल है file.txt। अब उसकी ज़रूरत नहीं।

इसे हटाने का एक तरीका है सिस्टम से सीधे डिलीट करना।

Linux, macOS, या Git Bash पर:

rm file.txt

Windows (कमांड प्रॉम्प्ट) पर: 

del file.txt

यह आपकी फ़ोल्डर से फ़ाइल डिलीट कर देता है। पर Git को अभी पता नहीं। इसलिए आपको Git को मैन्युअली बताना होगा कि फ़ाइल हटाई गई है:

git add file.txt

यह डिलीशन को स्टेज करता है ताकि वह अगले कमिट में शामिल हो।

अगर आपने कई फ़ाइलें डिलीट कीं और सभी याद नहीं, तो आप चला सकते हैं:

git add -u

यह सभी ट्रैक्ड फ़ाइलों के बदलाव या डिलीशन को स्टेज करता है। अनट्रैक्ड फ़ाइलें शामिल नहीं होंगी।

अब बदलाव कमिट करें:

git commit -m "Remove file.txt"

अगर आप git rm उपयोग करें, तो यह एक ही स्टेप में सब संभाल लेता है। यह फ़ाइल डिलीट करता है और तुरंत बदलाव को स्टेज कर देता है:

git rm file.txtgit commit -m "Remove file.txt"

अलग से git add चलाने की ज़रूरत नहीं। यह क्लीनर है और आप डिलीशन को स्टेज करना नहीं भूलेंगे।

संक्षेप में:

• मैनुअल डिलीशन में Git को बदलाव पकड़ने के लिए अतिरिक्त स्टेप चाहिए।
• अगर आप डिलीशन को स्टेज करना भूल गए, तो Git अभी भी सोचता रहेगा कि फ़ाइल मौजूद है, जिससे कमिट या मर्ज में भ्रम हो सकता है।
• git rm तब ज़्यादा क्लीन और सुरक्षित है जब आप जानबूझकर ट्रैक्ड फ़ाइलें हटा रहे हों।

Git में डिलीटेड फ़ाइलें वापस लाएँ

अगर आपने कोई फ़ाइल डिलीट कर दी और बाद में एहसास हुआ कि उसकी अभी भी ज़रूरत है? कोई बात नहीं। Git आपको उसे वापस लाने के कुछ तरीके देता है—यह इस पर निर्भर करता है कि आपको गलती कब पता चली।

अगर आपने अभी तक कमिट नहीं किया है:

मान लें आपने फ़ाइल डिलीट कर दी, पर बदलाव कमिट नहीं किया। आप उसे पिछले कमिट से ऐसे बहाल कर सकते हैं: 

git restore file.txt

यह फ़ाइल को नवीनतम कमिट से आपकी वर्किंग डायरेक्टरी में वापस लाता है।

अगर आपने डिलीशन पहले ही कमिट कर दिया है:

यह भी ठीक है। पहले वह आख़िरी कमिट ढूँढें जहाँ फ़ाइल मौजूद थी:

git log -- file.txt

लॉग देखें और वह कमिट हैश कॉपी करें जहाँ फ़ाइल थी। फिर चलाएँ:

git checkout <commit hash> -- file.txt

Git के पुराने वर्ज़न में आप ऊपर वाला कमांड उपयोग कर सकते थे। यह किसी विशेष कमिट से फ़ाइल रिस्टोर करता है, पर ब्रांच भी स्विच कर सकता था।

Git 2.23 से, इसे दो स्पष्ट कमांड में बाँटा गया:

• git switch (ब्रांच स्विच करने के लिए)
• git restore (फ़ाइलें रिस्टोर करने के लिए)

अगर आप सिर्फ़ किसी कमिट से फ़ाइल रिस्टोर करना चाहते हैं, तो यह उपयोग करें:

git restore --source=<commit-hash> --file.txt

यह उस कमिट से फ़ाइल खींचकर आपकी वर्किंग डायरेक्टरी में रख देता है।

अगर यकीन नहीं कि फ़ाइल कब डिलीट हुई:

हो सकता है आपने बहुत बदलाव किए हों और याद न हो कि फ़ाइल कब गायब हुई। ऐसे में, git reflog या रेफरेंस लॉग का उपयोग करें: 

git reflog

यह आपके Git कमिट, चेकआउट, रीसेट वगैरह—सबका पूरा इतिहास दिखाता है।

पर git reflog सिर्फ़ लोकल होता है और रिमोट पर काम नहीं करता। अगर आप रिमोट रिपो के साथ काम कर रहे हैं, तो उस फ़ाइल का इतिहास ट्रैक करने के लिए git log -- file.txt उपयोग करना बेहतर है।

एक बार वह पॉइंट मिल जाए जहाँ फ़ाइल मौजूद थी, तब पहले की तरह git checkout या git restore से उसे रिस्टोर कर लें।

Git में Missing फ़ाइलें ठीक करें

कभी-कभी फ़ाइलें सीधे सिस्टम से डिलीट हो जाती हैं—शायद फ़ाइल एक्सप्लोरर से, टर्मिनल के rm कमांड से, या गलती से। ऐसा होने पर, Git अपने-आप सफ़ाई नहीं करता। वह उन फ़ाइलों को missing के रूप में मार्क करता है और सही तरीके से हटाने के लिए आपका इंतज़ार करता है।

आइए देखें, ऐसी स्थिति में आपको चरणबद्ध तरीके से क्या करना चाहिए।

चरण 1: Missing फ़ाइलें जाँचें

अपने प्रोजेक्ट फ़ोल्डर में यह चलाएँ:

git status

अगर Git कहता है कि कोई फ़ाइल डिलीट हो गई है, तो इसका मतलब वह आपके सिस्टम से हट चुकी है, पर बदलाव अभी स्टेज नहीं हुआ।

चरण 2: डिलीशन को स्टेज करें 

Git को सभी बदलाव (डिलीटेड फ़ाइलें सहित) स्टेज करने के लिए बताने हेतु, चलाएँ:

git add -A

• git add -A = सभी बदलाव स्टेज करें (नए, संशोधित, डिलीटेड)।
• git add -u = संशोधित + डिलीटेड को स्टेज करें, पर नई फ़ाइलें नहीं।

यह सभी फ़ाइल बदलाव—नए, संशोधित, और डिलीटेड—स्टेज कर देता है। फिर अपडेट कमिट करें:

git commit -m "Removed missing files"

यह सबसे सुरक्षित सफ़ाई का तरीका है क्योंकि यह एक बार में हर बदलाव पकड़ लेता है।

चरण 3: रिमोट पर पुश करें 

अगर आप किसी रिमोट रिपॉजिटरी के साथ काम कर रहे हैं, तो कमिट पुश करें:

git push origin <branch-name>

<branch-name> को अपनी वर्किंग ब्रांच से बदलें, जैसे main या dev।

चरण 4: वैकल्पिक

मान लें आपने बहुत-सी फ़ाइलें मैन्युअली डिलीट कर दीं—शायद गलती से, या सफ़ाई करते हुए। Git तब तक मानता रहेगा कि वे फ़ाइलें मौजूद हैं जब तक आप उसे कुछ और न बताएं।

अगर आप हर एक को git rm से हटाना नहीं चाहते, तो चीज़ों को तेज़ी से साफ़ करने का एक तरीका है।

अपने टर्मिनल में यह कमांड चलाएँ:

git ls-files --deleted -z | xargs -0 git rm

यह क्या करता है:

• git ls-files --deleted उन सभी फ़ाइलों की सूची देता है जिन्हें Git ट्रैक कर रहा है पर जो अब आपकी डिस्क से गायब हैं।
• xargs -0 git rm उन फ़ाइल नामों को git rm को पास करके Git के इंडेक्स से हटा देता है।

यह बड़े प्रोजेक्ट पर काम करते हुए तेज़ी से सफ़ाई करने में काफ़ी मददगार है।

नोट: मुझे यह संदेश इसलिए मिला क्योंकि आपकी डिस्क से वर्तमान में कोई भी ट्रैक्ड फ़ाइल missing नहीं है।

Git में उन्नत फ़ाइल हटाना

अब जब हमने बेसिक्स कवर कर लिए हैं, तो चलिए उन उन्नत स्थितियों को देखें जहाँ Git से फ़ाइल हटाना सिर्फ़ git rm चलाने जितना सीधा नहीं होता। ये वे मामले हैं जहाँ संवेदनशील डेटा शामिल है या अनट्रैक्ड फ़ाइलों को सावधानी से साफ़ करना होता है।

Git से संवेदनशील डेटा हटाएँ

कभी-कभी निजी डेटा—जैसे API कुंजियाँ या पासवर्ड—वाली फ़ाइल गलती से कमिट हो जाती है। सामान्य डिलीट करना मददगार नहीं होगा। क्योंकि Git पूरा इतिहास रखता है, और वह फ़ाइल पुराने कमिट में मौजूद रहती है।

इसे पूरी तरह मिटाने के लिए, आप git filter-repo कमांड इस्तेमाल कर सकते हैं: git filter-repo (अनुशंसित)

यह filter-branch का नया और बेहतर विकल्प है। यह तेज़, सुरक्षित और उपयोग में आसान है।

पहले इसे इंस्टॉल करें (इसके लिए Python और pip चाहिए):

pip install git-filter-repo

फिर चलाएँ:

git filter-repo --path hide.txt --invert-paths

यह आपके रिपो के इतिहास के हर कमिट से hide.txt फ़ाइल को हटा देता है।

पुष्टि करने के लिए, चलाएँ:

git log --all -- supersecrets.txt

अगर फ़ाइल हट चुकी है, तो उसे दोबारा ट्रैक होने से रोकने के लिए .gitignore में जोड़ें:

echo hide.txt >> .gitignore

अगर आप टीम के साथ काम कर रहे हैं, तो री-राइट इतिहास को साफ़ करें और बदलावों को फ़ोर्स-पुश करें:

git push origin --force --all

फिर टीम के साथियों को बताएँ। त्रुटियों से बचने के लिए उन्हें अपनी लोकल कॉपीज़ को फिर से क्लोन या रीसेट करना होगा।

git clean से अनट्रैक्ड फ़ाइलें साफ़ करें

इसे तोड़कर देखें:

• Tracked फ़ाइलें Git के इतिहास में होती हैं। उन्हें हटाने के लिए git rm उपयोग करें, फिर कमिट करें।
• Untracked फ़ाइलें Git में बिल्कुल नहीं होतीं। ये इकट्ठा होकर आपके प्रोजेक्ट में अव्यवस्था पैदा कर सकती हैं।

अनट्रैक्ड फ़ाइलें या फ़ोल्डर डिलीट करने के लिए git clean का उपयोग करें।

यह रहे सबसे उपयोगी विकल्प:

git clean -n     # Show which untracked files will be removedgit clean -nd    # Show which untracked folders will be removedgit clean -fd    # Delete all untracked files and folders. It is destructive.

यहाँ:

• -n का मतलब केवल पूर्वावलोकन।
• -f का मतलब फोर्स डिलीट।
• -d सफ़ाई में फ़ोल्डरों को भी शामिल करता है।

नोट: git clean ट्रैक्ड फ़ाइलों को नहीं छूता। पर यह किसी भी अनट्रैक्ड चीज़ को डिलीट कर देगा, भले ही आप उसे रखना चाहते हों। इसलिए, हमेशा पहले -n का उपयोग करें ताकि देखें कि यह क्या हटाएगा।

GitHub और GUI टूल्स में फ़ाइल हटाना

अब तक हमने ज़्यादातर कमांड लाइन का उपयोग किया। पर हर कोई ऐसे काम नहीं करता और यह बिल्कुल ठीक है। कुछ डेवलपर सीधे GitHub में विज़ुअल टूल्स का उपयोग करते हैं।

तो देखते हैं, GitHub के वेब इंटरफ़ेस और अन्य GUI टूल्स में फ़ाइलें कैसे डिलीट होती हैं, और यह कमांड लाइन से कैसे तुलना करता है।

GitHub वेबसाइट में फ़ाइलें डिलीट करें

अगर आप GitHub के ब्राउज़र इंटरफ़ेस में काम कर रहे हैं, तो बिना टर्मिनल उपयोग किए फ़ाइलें डिलीट कर सकते हैं।

2025 इंटरफ़ेस में यह ऐसे काम करता है:

1. वह फ़ाइल खोलें जिसे आप डिलीट करना चाहते हैं।
2. ऊपरी-दाएँ कोने में तीन बिंदुओं पर क्लिक करें।
3. ड्रॉपडाउन से Delete file चुनें।

इसके बाद GitHub एक कमिट मैसेज बॉक्स दिखाएगा। एक छोटा संदेश जोड़ें, जैसे:

Delete practice.py

आप वैकल्पिक विवरण भी लिख सकते हैं।

फिर, बदलाव कैसे सहेजना है, चुनें:

• main ब्रांच में सीधे कमिट करें
• या नई ब्रांच बनाएँ और पुल रिक्वेस्ट शुरू करें (टीम वर्कफ़्लो के लिए अनुशंसित)

Commit changes पर क्लिक करें, और GitHub फ़ाइल को हटा देगा और डिलीशन को एक कमिट के रूप में सहेज देगा, ठीक वैसे ही जैसे कमांड लाइन से git rm करता है।

Git GUI टूल्स से फ़ाइलें डिलीट करें

अगर आप GitHub Desktop, Sourcetree, या Tower जैसे Git GUI का उपयोग करते हैं, तो प्रक्रिया भी सरल है:

1. फ़ाइल एक्सप्लोरर या ऐप के भीतर फ़ाइल डिलीट करें।
2. ऐप “Changes” या “File Status” के अंतर्गत डिलीशन दिखाएगा।
3. बदलाव की समीक्षा करें, स्टेज करें, और कमिट करें।

हर टूल थोड़ा अलग दिखता है, पर वर्कफ़्लो समान है: आप बदलावों को विज़ुअली ट्रैक करते हैं और तैयार होने पर कमिट करते हैं।

प्लेटफ़ॉर्म के अनुसार श्रेष्ठ प्रक्रिया

यह अलग-अलग प्लेटफ़ॉर्म पर फ़ाइल डिलीशन कैसे काम करता है और कब कौन-सा सबसे उपयोगी है, उस पर एक त्वरित नज़र:

• GitHub (वेब): त्वरित फ़िक्स और छोटे अपडेट के लिए अच्छा। बड़े क्लीनअप या संवेदनशील फ़ाइलों के लिए इससे बचें। 
• Git GUI टूल्स: रोज़मर्रा के काम के लिए बढ़िया। बदलाव देखना और सुरक्षित रूप से कमिट करना आसान। 
• कमांड लाइन: सबसे लचीला और सहायक। बल्क एडिट या इतिहास बदलने जैसे उन्नत कार्यों के लिए श्रेष्ठ। 

Git फ़ाइल हटाने के सर्वोत्तम अभ्यास

Git में फ़ाइलें हटाना सरल लग सकता है, पर एक गलत स्टेप आपका कोड तोड़ सकता है। यहाँ कुछ व्यावहारिक टिप्स हैं जिन्हें मैं उपयोग करता हूँ ताकि डिलीशन सुरक्षित और नियंत्रित रहें, खासकर साझा या लंबे समय के प्रोजेक्ट्स में।

डिलीट करने से पहले हमेशा सत्यापित करें

किसी फ़ाइल को हटाने से पहले, एक मिनट लें और जाँच लें कि वह क्या कर रही है:

• git status चलाएँ और देखें कि वह स्टेज्ड है या संशोधित।
• उसका कमिट इतिहास देखने के लिए git log -- <filename> का उपयोग करें।

यह त्वरित जाँच आगे चलकर मुझे घंटों की रिकवरी से बचा देती है।

एटॉमिक कमिट्स का उपयोग करें

एटॉमिक कमिट का मतलब है—एक तार्किक बदलाव पर एक कमिट।

उदाहरण के लिए, अगर मैं अनुपयोगी फ़ाइलें हटा रहा हूँ, तो मैं सिर्फ़ उन्हीं डिलीशन को कमिट करता हूँ, कोड एडिट से अलग।

यह इसलिए मददगार है:

• डीबगिंग सरल होती है। git bisect जैसे टूल छोटे और केंद्रित कमिट्स पर बेहतर काम करते हैं।
• कमिट इतिहास साफ़ और स्पष्ट रहता है।
• कोड रिव्यू तेज़ होते हैं।

इतिहास री-राइट पर सहयोग सावधानी से करें

git filter-repo जैसे टूल से इतिहास री-राइट करना आपकी पूरी टीम को प्रभावित करता है। अव्यवस्था से बचने के लिए:

• साझा ब्रांचेज़ को री-राइट करने से पहले संवाद करें।
• git push --force सावधानी से उपयोग करें, क्योंकि यह रिमोट इतिहास री-राइट करता है।
• बाद में साथियों को अपनी लोकल रिपो को फिर से क्लोन या रीसेट करने के लिए कहें।

विनाशकारी कमांड से पहले --dry-run का उपयोग करें

किसी भी डिलीट करने वाले कमांड को चलाने से पहले, हमेशा टेस्ट करें:

git clean -n

यह दिखाता है कि क्या डिलीट होगा, बिना कुछ डिलीट किए। मैं मानता हूँ कि आपको यह हमेशा करना चाहिए क्योंकि: 

• यह उन फ़ाइलों को हटने से बचाता है जिन्हें आप वास्तव में रखना चाहते हैं।
• यह एक सेफ़्टी नेट है, खासकर बड़े प्रोजेक्ट्स में जहाँ एक गलती से लॉग या जेनरेटेड फ़ाइलें मिट सकती हैं।

git rm --cached को .gitignore के साथ मिलाएँ

अगर आपने गलती से कुछ ऐसा कमिट कर दिया जो रिपो में नहीं होना चाहिए (जैसे कोई कॉन्फ़िग फ़ाइल या लॉग), तो इसे दो स्टेप में ठीक करें:

1. फ़ाइल को अनट्रैक करें:```git rm --cached <filename>

git rm --cached <filename>

यह Git को फ़ाइल ट्रैक करना बंद करने को कहता है, पर उसे आपके कंप्यूटर पर रहने देता है।

1. उसे .gitignore में जोड़ें:

echo <filename> >> .gitignore

यह इसलिए मददगार है:

• संवेदनशील या लोकल फ़ाइलें (जैसे .env, .log, या node_modules) रिपो से बाहर रहती हैं।
• आपके Git इतिहास में अव्यवस्था नहीं बढ़ती।
• आगे उन फ़ाइलों में बदलाव Git में बदलाव ट्रिगर नहीं करेंगे।

Git की Edge Cases: स्टेजिंग और खाली फ़ोल्डर

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

यहाँ मैं आम किनारों (edge cases) को कैसे संभालता हूँ।

बिना बदलाव खोए फ़ाइल को अनस्टेज करें

मान लें मैंने git add . चलाया और गलती से कोई फ़ाइल स्टेज हो गई। मैं अपने बदलाव खोना नहीं चाहता—बस उसे अनस्टेज करना है।

इसे ठीक करने के लिए, मैं चलाता हूँ:

git reset HEAD <filename>

यह फ़ाइल को अनस्टेज करता है, पर एडिट्स को बनाए रखता है।

पुष्टि करने के लिए, मैं उपयोग करता हूँ:

git status

अब फ़ाइल "modified" दिखनी चाहिए, "staged" नहीं।

रिपो में खाली फ़ोल्डर रखना

डिफ़ॉल्ट रूप से, Git खाली फ़ोल्डर को नज़रअंदाज़ करता है। अगर मैं किसी फ़ोल्डर को बिना फ़ाइलों के कमिट करने की कोशिश करूँ, तो Git उसे स्किप कर देगा।

पर कभी-कभी मैं उस फ़ोल्डर को रिपो में रखना चाहता हूँ—भविष्य के लॉग्स या अपलोड्स के लिए। आम समाधान है .gitkeep नाम की प्लेसहोल्डर फ़ाइल जोड़ना।

ऐसे करें:

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"

यह फ़ोल्डर को "गैर-खाली" बना देता है, ताकि Git उसे ट्रैक करे।

नोट: .gitkeep Git में अंतर्निर्मित नहीं है। यह सिर्फ़ एक प्रचलन (कन्वेंशन) है। आप फ़ाइल का कोई भी नाम रख सकते हैं, पर .gitkeep दूसरों को इसका उद्देश्य बता देता है।

Git फ़ाइल हटाने की ट्रबलशूटिंग

यहाँ कुछ सामान्य समस्याएँ हैं जिनसे मैं Git में फ़ाइलें हटाते समय गुज़रा हूँ, और उनके समाधान।

फ़ाइल अभी भी रिमोट रिपॉजिटरी में दिख रही है

आपने फ़ाइल डिलीट कर दी, बदलाव कमिट भी कर दिया, पर वह रिमोट रिपो पर अभी भी है। शायद आप पुश करना भूल गए।

तो यह चलाना सुनिश्चित करें:

git push origin <branch-name>

यह भी जाँचें:

• क्या आप सही ब्रांच पर हैं?
• क्या आपके कमिट में फ़ाइल डिलीशन वास्तव में शामिल था?

सबमॉड्यूल से जुड़ी समस्याएँ

सबमॉड्यूल दूसरे Git रिपॉजिटरी होते हैं जो किसी Git रिपॉजिटरी के अंदर होते हैं। ये सामान्य फ़ोल्डरों की तरह व्यवहार नहीं करते।

अगर आप किसी सबमॉड्यूल के अंदर फ़ाइलें डिलीट कर रहे हैं:

• सबमॉड्यूल फ़ोल्डर में जाएँ
• उसी सबमॉड्यूल के अंदर से बदलाव कमिट और पुश करें

अगर आप पूरे सबमॉड्यूल को ही हटा रहे हैं:

• सबमॉड्यूल फ़ोल्डर डिलीट करें
• .gitmodules और .git/config में से संबंधित रेफ़रेंस हटाएँ

Detached HEAD स्थिति

Git में, HEAD आमतौर पर वर्तमान ब्रांच की ओर इशारा करता है। पर कभी-कभी यह किसी विशेष कमिट की ओर इशारा करता है—इसे detached HEAD कहते हैं।

ऐसा तब होता है जब आप:

• किसी कमिट को उसके हैश से चेकआउट करते हैं
• किसी टैग पर स्विच करते हैं
• किसी रिमोट ब्रांच को बिना ट्रैकिंग सेट किए चेकआउट करते हैं

अपनी स्थिति जाँचें:

git status

अगर आप यह देखते हैं:

HEAD detached at <commit-hash>

आप किसी ब्रांच पर नहीं हैं, और कोई भी नया बदलाव तब खो सकता है जब आप स्विच करेंगे।

इसे ऐसे ठीक करें: 

अगर आपने बदलाव किए हैं और उन्हें रखना चाहते हैं, तो यह चलाएँ:

git checkout -b <new-branch-name>

यह आपके काम को नई ब्रांच पर रख देता है और सेव कर देता है।

अगर आपने बदलाव कमिट कर दिए हैं और बाद में उन्हें किसी दूसरी ब्रांच में ले जाना चाहते हैं, तो यह करें:

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branch

अगर आपने कोई बदलाव नहीं किया और सिर्फ़ detached HEAD से बाहर आना चाहते हैं, तो यह चलाएँ:

git checkout <branch-name> 

बस। अब आपका HEAD री-अटैच हो गया है, और सब सामान्य है।

अनुमति या स्टेट त्रुटियाँ

कभी-कभी Git फ़ाइल डिलीट नहीं करेगा—आम तौर पर Windows पर। ऐसा तब हो सकता है जब:

• फ़ाइल किसी दूसरे प्रोग्राम में खुली हो
• Git के पास उसे अपडेट करने की अनुमति न हो

इसे ऐसे ठीक करें:

• फ़ाइल उपयोग कर रहे ऐप्स बंद करें
• अपने टर्मिनल को Administrator के रूप में रीस्टार्ट करें (Windows पर)

मर्ज या रिबेस समस्याएँ

अगर आपको ऐसे एरर दिखें:

• you are not currently on a branch
• merge conflict

संभावना है कि आप किसी मर्ज या रिबेस के बीच में हैं।

कन्फ्लिक्ट सुलझाने के बाद रिबेस पूरा करने के लिए:

git rebase --continue

रिबेस या मर्ज पूरी तरह रद्द करने के लिए:

git reset --merge

यह आपकी रिपो को उसी स्थिति में बहाल करता है जैसी वह मर्ज शुरू होने से पहले थी।

सारी लोकल चेंजिस छोड़कर अपनी वर्किंग डायरेक्टरी रीसेट करना चाहते हैं? 

यह आज़माएँ:

git restore .

यह सभी फ़ाइलों को उनके आख़िरी कमिट वाली स्थिति में लौटा देता है।

अंतिम विचार 

Git में फ़ाइलें हटाते समय, अगर आप ध्यान नहीं देते तो गलती करना आसान है। एक छोटी-सी गलती बड़े मुद्दे पैदा कर सकती है: टूटा हुआ कोड, खोया हुआ काम, या आपकी टीम में भ्रम। इसलिए, जो भी कर रहे हैं, उसे एक बार दोबारा जाँच लें।

स्थिति के अनुसार सही कमांड का उपयोग करें। अगर यकीन नहीं कि कोई कमांड क्या करेगा, पहले उसे dry run के साथ टेस्ट करें। और अगर आप दूसरों के साथ काम कर रहे हैं, तो सुनिश्चित करें कि सब एक ही पेज पर हों।

फ़ाइलें डिलीट करने से आगे भी Git बहुत कुछ कर सकता है। आप ब्रांचें डिलीट कर सकते हैं, reset और revert से गलतियाँ वापस ले सकते हैं, या git diff से ठीक-ठीक देख सकते हैं कि क्या बदला। जितना ज़्यादा सीखेंगे, आपका वर्कफ़्लो उतना ही सुचारू होगा।

एक-एक कदम बढ़ाएँ। ऐसे ही आप इसमें माहिर बनते हैं।