कैसे ट्रैक किया गया था जो एक फ़ाइल के बारे में "भूल" बनाने के लिए है, लेकिन अब .gitignore में है?

Question

एक फ़ाइल है जिसे ट्रैक किया जा रहा था git , लेकिन अब फ़ाइल .gitignoreसूची में है।

हालाँकि, यह फ़ाइल git statusसंपादित होने के बाद दिखाई देती रहती है । आप gitइसे पूरी तरह से भूलने के लिए कैसे मजबूर करते हैं ?

Comments

git clean -Xसमान लगता है, लेकिन यह इस स्थिति में लागू नहीं होता है (जब फाइलें अभी भी गिट द्वारा ट्रैक की जा रही हैं)। मैं गलत रास्ता का पालन नहीं करने के लिए एक समाधान की तलाश में किसी के लिए यह लिख रहा हूँ।

— इम्ज़ - इवान ज़खरीशेव

इसका एकमात्र वास्तविक उत्तर नीचे है, देखें git update-index --assume-unchanged। यह समाधान 1) फ़ाइल को सर्वर (इंडेक्स) पर रखता है, 2) आपको स्थानीय रूप से इसे स्वतंत्र रूप से संशोधित करने देता है।

— क्वर्टी

आपको उपयोग करने की आवश्यकता है --skip-worktree, देखें: stackoverflow.com/questions/13630849/…

— Doppelganger

एक महत्वपूर्ण प्रश्न यह है कि क्या फाइल रिपॉजिटरी में होनी चाहिए या नहीं? उदाहरण के लिए, अगर कोई नया रेपो क्लोन करता है, तो क्या उसे फाइल मिलनी चाहिए या नहीं? यदि हां तो git update-index --assume-unchanged <file>सही है और फाइल रिपॉजिटरी में रहेगी और इसमें बदलाव नहीं किए जाएंगे git add। यदि NO (उदाहरण के लिए यह कुछ कैश फ़ाइल, उत्पन्न फ़ाइल आदि) थी, तो git rm --cached <file>इसे रिपॉजिटरी से हटा देगा।

— मार्टिन

@ मर्टिन @ क्वर्टी को सलाह देने के लिए रुकना चाहिए --assume-unchangedजिसके लिए प्रदर्शन को रोकने के लिए बड़ी ट्रैक की गई फ़ाइलों की स्थिति की जांच करना --skip-worktreeहै, लेकिन यह पसंद करें कि संशोधित ट्रैक की गई फ़ाइलों के लिए है जो उपयोगकर्ता अब और नहीं करना चाहते हैं। देखें stackoverflow.com/questions/13630849/...

— फिलिप

Answer 1

.gitignoreadd -fgit द्वारा ट्रैक की गई फ़ाइलों के सेट में अनट्रैक की गई फ़ाइलों को (बिना ) जोड़े जाने से रोकेगा , हालाँकि git उन फ़ाइलों को ट्रैक करना जारी रखेगा जो पहले से ट्रैक की जा रही हैं।

किसी फ़ाइल को ट्रैक करने से रोकने के लिए आपको उसे इंडेक्स से निकालने की आवश्यकता है। यह इस आदेश के साथ प्राप्त किया जा सकता है।

git rm --cached <file>

यदि आप एक संपूर्ण फ़ोल्डर को निकालना चाहते हैं, तो आपको पुन: इसमें सभी फ़ाइलों को निकालने की आवश्यकता है।

git rm -r --cached <folder>

हेड रिवीजन से फाइल हटाने का काम अगले कमिट पर होगा।

चेतावनी: हालांकि यह आपके स्थानीय से भौतिक फ़ाइल को नहीं हटाएगा, यह अगले पर अन्य डेवलपर्स मशीनों से फ़ाइलों को हटा देगा git pull।

Comments

मेरे लिए काम करने वाली प्रक्रिया थी 1. पहले लंबित बदलाव। 2. gm rm --cached <file> और फिर से कमिट करना। 3. फ़ाइल को .itignore पर, git स्टेटस के साथ चेक करें और फिर से कम करें

— mataal

बहुत महत्वपूर्ण जोड़ना। यदि फ़ाइल को अनदेखा किया जाता है, तो उसे संशोधित किया जाएगा (लेकिन इसके बावजूद इसे कमिट नहीं किया जाना चाहिए), संशोधित करने और निष्पादित करने के बाद git add .इसे इंडेक्स में जोड़ा जाएगा। और अगली प्रतिबद्धता यह भंडार के लिए प्रतिबद्ध होगी। : इस पर अमल सही होने के बाद वह सब mataal एक और आदेश से बचने के लिए कहाgit update-index --assume-unchanged <path&filename>

— दाव

@AkiraYamamoto की विधि ने मेरे लिए भी अच्छा काम किया। मेरे मामले में मैंने उत्पादन को दबा दिया क्योंकि मेरी रिपॉजिटरी में हजारों फाइलें थीं:git rm -r -q --cached .

— हारून ब्लेंकश

git pullहालांकि यह फ़ाइल को हटा देगा ।

— पेट्र पेलर

git rm --cached <file> बस फाइल को रिपॉजिटरी से हटा दें, git अपडेट-इंडेक्स --assume-अपरिवर्तित <फ़ाइल> फ़ाइल को अस्थिर परिवर्तनों में नहीं दिखाया गया है और एक नया बदलाव नहीं करता है। लेकिन मैं चाहता हूं कि बस नौवीं कक्षा के छात्रों का पाठ्यक्रम

— इगोर सेमिन

Answer 2

नीचे दिए गए आदेशों की श्रृंखला Git Index (वर्किंग डायरेक्टरी या लोकल रेपो से नहीं) से सभी आइटम्स को हटा देगी और फिर Git इंडेक्स को अपडेट करते हुए Git इंडेक्स को अपडेट करेगी। पुनश्च। इंडेक्स = कैश

प्रथम:

git rm -r --cached . 
git add .

फिर:

git commit -am "Remove ignored files"

---

या एक-लाइनर:

git rm -r --cached . && git add . && git commit -am "Remove ignored files"

Comments

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

— लुडविग

स्वीकृत उत्तर के रूप में भी। फाइलें डिलीट हो जाएंगी git pull।

— पेट्र पेलर

यह एक मानक git कमांड के रूप में होना अच्छा होगा। कुछ इस तरह git rmignored।

— बेरिक

@gudthing -r का अर्थ "पुनरावर्ती" है

— मार्क

इसके साथ आप अन्य बेकार फ़ाइलों को जोड़ सकते हैं जो वर्तमान में नहीं हैं .gitignore। यह पता लगाना मुश्किल हो सकता है कि git statusइस आदेश के बाद आपका शोर कितना निर्भर करता है। एक आदेश जो केवल नई उपेक्षित फ़ाइलों को हटाता है वह बेहतर होगा। यही कारण है कि मैं थिसॉफ्ट का जवाब

— कुरजामेटल

Answer 3

git अपडेट-इंडेक्स मेरे लिए काम करता है:

git update-index --assume-unchanged <file>

नोट: यह समाधान वास्तव में स्वतंत्र है .gitignoreक्योंकि gitignore केवल अनट्रैक फ़ाइलों के लिए है।

संपादित करें: चूंकि यह उत्तर पोस्ट किया गया था, इसलिए एक नया विकल्प बनाया गया है और इसे प्राथमिकता दी जानी चाहिए। आपको --skip-worktreeसंशोधित ट्रैक की गई फ़ाइलों के लिए उपयोग करना चाहिए जो उपयोगकर्ता अब और कमिट नहीं करना चाहते हैं और --assume-unchangedबड़ी ट्रैक की गई फ़ाइलों की स्थिति की जाँच करने के लिए प्रदर्शन को रोकने के लिए प्रदर्शन करना चाहते हैं । अधिक जानकारी के लिए https://stackoverflow.com/a/13631525/717372 देखें ...

git update-index --skip-worktree <file>

Comments

यह है असली जवाब। वास्तव में बहुत ही सरल, प्रदूषित नहीं करता है git statusऔर वास्तव में बहुत सहज है। धन्यवाद।

— पाब्लो ओल्मोस डी एगुइलेरा सी।

मैं अच्छे पर्याप्त rm [...] .समाधान के लिए गया था , कम से कम मैं इसे कैसे काम कर सकता हूं, इसके बारे में सोच सकता हूं। मुझे क्या update-indexऔर क्या नहीं पर कोई महान दस्तावेज मिला --assume-unchanged। क्या कोई जोड़ सकता है कि यह दूसरे से कैसे तुलना करता है, इसमें मैं उन सभी फाइलों को हटाना चाहूंगा जिन्हें अनदेखा किया गया होगा? (या स्पष्ट स्पष्टीकरण के लिए एक कड़ी?)

— ब्रैडी ट्रेनर

git update-index --assume-unchanged <path> …बिना किसी परवाह किए निर्दिष्ट पथ में परिवर्तनों को अनदेखा करने का कारण होगा .gitignore। यदि आप किसी दूरस्थ से खींचते हैं और उस दूरस्थ में इस पथ में परिवर्तन होते हैं, तो गिट एक संघर्ष के साथ विलय को विफल कर देगा और आपको मैन्युअल रूप से विलय करने की आवश्यकता होगी। git rm --cached <path> …उस रास्ते पर नज़र रखने से रोकने के लिए गिट का कारण होगा। यदि आप अपने रास्ते को नहीं जोड़ते .gitignoreहैं तो भविष्य में आपको रास्ता दिखाई देगा git status। पहले विकल्प में जीआईटी प्रतिबद्ध इतिहास में कम शोर है और भविष्य में वितरित की जाने वाली "उपेक्षित" फ़ाइल में परिवर्तन की अनुमति देता है।

— मैनीकेडी

मैं काफी उलझन में हूँ कि यह स्वीकृत उत्तर कैसे नहीं है। यहाँ स्वीकृत उत्तर स्पष्ट रूप से पूछे जा रहे वास्तविक प्रश्न का उत्तर नहीं दे रहा है। यह उत्तर उस फ़ाइल के परिवर्तनों को अनदेखा करता है जो रिपॉजिटरी में है, जबकि रिपॉजिटरी से इसे नहीं हटा रहा है।

— डेव कूपर

यह उत्तर बहुत अधिक उपयोगी होगा यदि यह स्पष्ट रूप से बताए कि दिए गए आदेश क्या करते हैं, उदाहरण के लिए यह अन्य सुझाए गए समाधानों से कैसे भिन्न है।

— लार्श

Answer 4

git ls-files --ignored --exclude-standard -z | xargs -0 git rm --cached
git commit -am "Remove ignored files"

यह अनदेखा फ़ाइलों की सूची लेता है और उन्हें सूचकांक से निकालता है, फिर परिवर्तन करता है।

Comments

यदि आपको उन्हें कार्यशील निर्देशिका से भी निकालने की आवश्यकता है, तो बस चलाएं git ls-files --ignored --exclude-standard | xargs git rm । मेरा मानना ​​है कि यह उत्तर सबसे अच्छा है! क्योंकि यह बहुत स्पष्ट है, यूनिक्स-वे है, और दूसरे, अधिक जटिल आदेशों के साइड-इफेक्ट्स की रचना किए बिना, एक प्रत्यक्ष तरीके से वांछित काम करता है।

— इम्ज़ - इवान ज़खरीशेव

बहुत बढ़िया जवाब; हालाँकि, यदि आप बीच पर रिक्त स्थान रखते हैं, तो कमांड विफल हो जाएगी, जैसे: "My dir / my_ignored_file.txt"

— डेविड हर्नांडेज़

git ls-files --ignored --exclude-standard | sed 's /.*/"&"/' | xargs git rm

— डेविड हर्नांडेज़

git rmls-filesकुछ भी मेल नहीं खाने पर शिकायत करेंगे । यदि कोई फाइल मेल नहीं खाती है, तो xargs -r git rm ...उसे xargsन चलाने के लिए कहने के लिए उपयोग करें git rm।

— वोल्फगैंग

विभाजक के रूप में \ 0 का उपयोग करना बेहतर होगा:git ls-files --ignored --exclude-standard -z|xargs -0 git rm --cached

— निल्स-ओ-मैट

Answer 5

मैं हमेशा इस कमांड का इस्तेमाल उन अनटैक की गई फाइलों को हटाने के लिए करता हूं। एक-लाइन, यूनिक्स-शैली, स्वच्छ आउटपुट:

git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

यह आपकी सभी उपेक्षित फाइलों को सूचीबद्ध करता है, अंदर के रिक्त स्थान के साथ पथों को संभालने के लिए प्रत्येक आउटपुट लाइन को एक उद्धृत लाइन के साथ प्रतिस्थापित करता है, और git rm -r --cachedइंडेक्स से पथ / फाइल / डायर को हटाने के लिए सब कुछ पास करता है।

Comments

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

— जॉन कैटमुल

मुझे भी यह "सबसे साफ" लगा। यह स्पष्ट हो सकता है, लेकिन बस पहले भाग को चलाने git ls-files --ignored --exclude-standardपर, आप अपने स्वयं को पहले समझने / सत्यापित करने की अनुमति देते हैं कि आपके नए .gitignoreको बाहर करने / हटाने से पहले क्या फाइलें चल रही हैं, और इससे पहले कि आप अंतिम निष्पादित करें git rm।

— जॉनब्रवे

ज्ञात हो, उन में कुछ "बुरा" वर्ण के साथ फ़ाइल नाम पर विफल रहता है, जैसे \n। मैंने इसके लिए पूरा करने के लिए अपना समाधान पोस्ट किया है।

— जोनब्रवे

एक और चेतावनी: पुल पर, इससे फाइल दूसरों की वर्किंग डायरेक्टरी में डिलीट हो जाएगी, है ना?

— लार्स

की कोशिश की, लेकिन मेरे लिए काम नहीं किया: sed: 1: "s/.*/": unterminated substitute in regular expressionरिक्त स्थान के साथ एक रेपो पर एक फिल्टर-शाखा कमांड में। (हालांकि फ़िल्टर-शाखा के बाहर काम करने के लिए लगता है)। मैं प्रयोग किया जाता git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cachedसे @ JonBrave के जवाब के बजाय।

— goofology

Answer 6

इसे बाहर ले जाएं, प्रतिबद्ध करें, फिर इसे वापस ले जाएं। यह मेरे लिए अतीत में काम कर चुका है। इसे पूरा करने के लिए शायद एक 'गिटियर' तरीका है।

Comments

यदि आपने पहले अनदेखा नहीं की गई फ़ाइलों का एक समूह को अनदेखा करना चाहते हैं तो यह बहुत अच्छा है। हालांकि जैसा आपने कहा, इसके लिए एक बेहतर तरीका है।

— Oskar Persson

यह वास्तव में वही है जो मैंने किया है। बस फ़ाइलों को git के बाहर एक फ़ोल्डर में ले जाएं, फिर "git add।", "Git कमिट" करें। (यह फ़ाइलों को हटा दिया गया) फिर gitignore जोड़ें, फ़ाइलों / फ़ोल्डरों का संदर्भ देते हुए, gitignore फ़ाइल को git में जोड़ने के लिए फिर से प्रतिबद्ध करें, फिर फ़ोल्डर्स में कॉपी / मूव करें, और उन्हें अनदेखा किया जाए। एनबी: यह दिखाई देगा कि फाइलें जीआईटी से हटा दी गई थीं, इसलिए संभवत: उन्हें अन्य चेकआउट / पुल से हटा दिया जाएगा, जैसा कि ऊपर दिए गए समाधानों में बताया गया है, लेकिन चूंकि आप शुरू में उनकी प्रतियां बना रहे हैं, इसलिए यह एक मुद्दे के रूप में ज्यादा नहीं है IMHO। बस बाकी टीम को बताएं ...

— Del

गलत तरीके से किए गए फ़ोल्डरों से छुटकारा पाने का यह सबसे आसान तरीका है।

— मार्टलार्क

एक ही रास्ता लगता है, जिसे मैं देख सकता हूं। यह एक विशाल बग ('फ़ीचर' नहीं) है जो कि जैसे ही आप एक फ़ाइल / फ़ोल्डर को .gitignore में जोड़ते हैं, यह उस फ़ाइल को उस बिंदु से - हमेशा - हर जगह अनदेखा नहीं करता है।

— जोसेफ

यह काम करने के बाद मैंने उन्हें जोड़ा था, और फिर इस तथ्य के बाद उन्हें

— .gitignore

Answer 7

यदि आप git rmएक ट्रैक की गई फ़ाइल को नहीं देख सकते हैं क्योंकि अन्य लोगों को इसकी आवश्यकता हो सकती है (चेतावनी, यदि आप git rm --cached , जब किसी और को यह परिवर्तन मिलता है, तो उनकी फाइल उनके फाइल सिस्टम में हटा दी जाएगी)। ये अक्सर कॉन्फ़िगर फ़ाइल ओवरराइड्स, प्रमाणीकरण क्रेडेंशियल्स आदि के कारण किया जाता है। कृपया उन लोगों के लिए https://gist.github.com/1423106 देखें जो समस्या के आसपास काम कर चुके हैं।

संक्षेप में:

• अपने आवेदन को एक अनदेखा फ़ाइल config-overide.ini के लिए देखें और उस प्रतिबद्ध फ़ाइल config.ini पर उपयोग करें (या वैकल्पिक रूप से, ~ / .config / myapp.ini, या $ MYCONFIGFILE के लिए देखें)
• फ़ाइल config-sample.ini के लिए प्रतिबद्ध करें और फ़ाइल config.ini को अनदेखा करें, यदि आवश्यक हो तो एक स्क्रिप्ट या समान फ़ाइल की प्रतिलिपि बनाएँ।
• आपके लिए परिवर्तनों को लागू करने और हटाने के लिए gitattributes क्लीन / स्मज मैजिक का उपयोग करने का प्रयास करें, उदाहरण के लिए, एक वैकल्पिक शाखा से चेकआउट के रूप में कॉन्फिग फाइल को स्मज करें और HEAD से चेकआउट के रूप में कॉन्फिग फाइल को साफ करें। यह मुश्किल सामान है, मैं नौसिखिए उपयोगकर्ता के लिए यह सिफारिश नहीं है।
• कॉन्फ़िगर फ़ाइल को उस पर समर्पित एक तैनाती शाखा पर रखें जो कभी भी मास्टर में विलय न हो। जब आप परिनियोजित / संकलित / परीक्षण करना चाहते हैं तो आप उस शाखा में विलीन हो जाते हैं और उस फाइल को प्राप्त कर लेते हैं। यह अनिवार्य रूप से मानव मर्ज नीतियों और अतिरिक्त-गिट मॉड्यूल का उपयोग करने के अलावा स्मज / स्वच्छ दृष्टिकोण है।
• विरोधी पुनर्संयोजन: ग्रहण-अपरिवर्तित का उपयोग न करें, यह केवल आँसू में समाप्त हो जाएगा (क्योंकि खुद को झूठ बोलने से बुरी चीजें घटित होंगी, जैसे आपका परिवर्तन हमेशा के लिए खो जाता है)।

Comments

अगर यह हटाने के समय गंदा था तो git फ़ाइल को नहीं हटाएगा। और अगर यह गंदा नहीं है, तो फ़ाइल को पुनर्प्राप्त करना उतना आसान होगा git checkout <oldref> -- <filename>- लेकिन फिर इसे बाहर की जाँच और अनदेखा किया जाएगा।

— Amenthes

अपने अंतिम नोट के बारे में (के बारे में --assume-unchanged): या तो यह कार्गो पंथ है और इसे खारिज कर दिया जाना चाहिए, या आप समझा सकते हैं कि क्यों (जो मैं आश्वस्त हूं) और यह उपयोगी हो जाता है।

— रोमेनैवलेरी

Answer 8

इसका उपयोग तब करें जब:

1. आप बहुत सारी फ़ाइलों को अनट्रैक करना चाहते हैं, या

2. आपने अपनी gitignore फ़ाइल अपडेट कर दी है

स्रोत लिंक: http://www.codeblocq.com/2016/01/Untrack-files-already-added-to-git-repository-based-on-gitignore/

मान लें कि आपने अपनी गिट रिपॉजिटरी में कुछ फाइलें पहले ही जोड़ दी हैं या कर दी हैं और फिर आप उन्हें अपने .gitignore में जोड़ सकते हैं; ये फ़ाइलें अभी भी आपके भंडार सूचकांक में मौजूद होंगी। यह लेख हम देखेंगे कि उनसे कैसे छुटकारा पाया जाए।

चरण 1: अपने सभी परिवर्तनों को कमिट करें

आगे बढ़ने से पहले, सुनिश्चित करें कि आपकी सभी परिवर्तन प्रतिबद्ध हैं, जिसमें आपकी .gitignore फ़ाइल शामिल है।

चरण 2: भंडार से सब कुछ निकालें

अपने रेपो को खाली करने के लिए, उपयोग करें:

git rm -r --cached .

• rm रिमूवल कमांड है
• -r पुनरावर्ती हटाने की अनुमति देगा
• -अंकित केवल सूचकांक से फ़ाइलों को हटा देगा। आपकी फाइलें अभी भी वहीं रहेंगी।

rmआदेश माफ हो सकता है। यदि आप कोशिश करना चाहते हैं कि यह पहले से क्या करता है, -nया जोड़ें--dry-run चीजों को परखने के लिए ध्वज ध्वज ।

चरण 3: सब कुछ जोड़ें

git add .

चरण 4: प्रतिबद्ध

git commit -m ".gitignore fix"

आपका भंडार साफ है :)

परिवर्तनों को प्रभावी रूप से देखने के लिए अपने रिमोट में परिवर्तन पुश करें।

Comments

यह दूरस्थ रिपॉजिटरी से फ़ाइलों को नहीं हटाएगा? क्या होगा अगर मैं फ़ाइलों को स्थानीय रेपो और रिमोट रेपो दोनों में रखना चाहता हूं, लेकिन उनके बारे में "भूल" कर सकता हूं?

— अविषय

AFAIK यह इतिहास से फ़ाइलों को नहीं हटाएगा क्योंकि हम किसी भी इतिहास को बदलने वाली कमांड का उपयोग नहीं कर रहे हैं (मुझे सही करें यदि मैं "गलत हूं")। यह केवल gitignore से gitignore में नजरअंदाज की गई फ़ाइलों को हटाकर एक नई प्रतिबद्धता जोड़ता है। वे फाइलें वहां होंगी। ऐतिहासिक घटनाएँ

— धीरज भास्कर

Answer 9

मैंने इसे git फ़िल्टर-शाखा का उपयोग करके पूरा किया । मेरे द्वारा उपयोग की गई सटीक कमांड मैन पेज से ली गई थी:

चेतावनी : यह आपके संपूर्ण इतिहास की फ़ाइल को हटा देगा

git filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD

यह कमांड पूरे प्रतिबद्ध इतिहास को फिर से बनाएगी, git rmप्रत्येक प्रतिबद्ध से पहले निष्पादित होगी और इसलिए निर्दिष्ट फ़ाइल से छुटकारा मिलेगा। कमांड को चलाने से पहले इसे वापस करना न भूलें क्योंकि यह खो जाएगा ।

Comments

यह सभी प्रतिबद्ध आईडी को बदल देगा, इस प्रकार रिपॉजिटरी की आपकी कॉपी के बाहर शाखाओं से विलय को तोड़ देगा।

— 19

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

— zebediah49

Answer 10

मेरे लिए क्या काम नहीं आया

(लिनक्स के तहत), मैं ls-files --ignored --exclude-standard | xargs git rm -r --cachedदृष्टिकोण का सुझाव देते हुए यहां के पदों का उपयोग करना चाहता था । हालाँकि, हटाई जाने वाली कुछ फ़ाइलों \nमें उनके नाम की एक अंतर्निहित नई पंक्ति / LF / थी। न तो समाधान:

git ls-files --ignored --exclude-standard | xargs -d"\n" git rm --cached
git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

इस स्थिति का सामना करें (नहीं मिली फ़ाइलों के बारे में त्रुटियां प्राप्त करें)।

तो मैं पेश करता हूं

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached
git commit -am "Remove ignored files"

यह ls-files के -zतर्क का उपयोग करता है , और xargs के तर्क का-0 फ़ाइल नाम में "गंदा" वर्णों को सुरक्षित / सही ढंग से पूरा करने के ।

मैनुअल पेज git-ls-files (1) में यह कहा गया है:

जब -z विकल्प का उपयोग नहीं किया जाता है, तो टीएबी, एलएफ और बैकस्लैश अक्षरों को पथनाम में क्रमशः \ t, \ n और \\ के रूप में दर्शाया जाता है।

इसलिए मुझे लगता है कि अगर मेरे नाम में इनमें से कोई भी चरित्र है तो मेरे समाधान की आवश्यकता है।

Comments

मेरे लिए यह सबसे अच्छा उपाय है। यह एक से बेहतर प्रदर्शन किया है git add .। इसमें ऊपर की कुछ टिप्पणियों से सर्वश्रेष्ठ सुधार भी शामिल हैं।

— निल्स-ओ-मैट

क्या आप git commit -am "Remove ignored files"अपने जवाब के बाद thSoft को जोड़ सकते हैं ? आपके जवाबों ने मुझे चीजों के माध्यम से मिला दिया: j

— kando

मुझे इसका उद्देश्य समझ नहीं आ रहा है git commit -a। मेरे लिए git rm --cachedवास्तव में सूचकांक को प्रभावित करता है इसलिए फ़ाइलों को चरणबद्ध करने की आवश्यकता नहीं है ...

— जीन पॉल

Answer 11

1. अपनी .gitignoreफ़ाइल को अपडेट करें - उदाहरण के लिए, एक फ़ोल्डर जोड़ें जिसे आप ट्रैक नहीं करना चाहते हैं .gitignore।

2. git rm -r --cached .- वांछित और अवांछित सहित सभी ट्रैक की गई फ़ाइलों को हटा दें। आपका कोड तब तक सुरक्षित रहेगा जब तक आप स्थानीय स्तर पर सहेज चुके हैं।

3. git add .- उन सभी फाइलों को वापस जोड़ दिया जाएगा, जिनको छोड़कर .gitignore।

---

हमें सही दिशा में इंगित करने के लिए @AkiraYamamoto को हैट टिप।

Comments

इस तथ्य के कारण कि यह वास्तव में कैसे काम करेगा, इस कारण से आपको कम-से-कम rm चलाने की जरूरत नहीं है :) (किसी ने सही तरीके से कॉपी नहीं की है)

— अरन मुल्होलैंड

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

— orrd

Answer 12

मुझे लगता है, कि शायद गर्भाधान के कारण फ़ाइल पूरी तरह से फ़ाइल के बारे में नहीं भूल सकती है ( खंड "स्नैपशॉट्स, अंतर नहीं" )।

यह समस्या अनुपस्थित है, उदाहरण के लिए, सीवीएस का उपयोग करते समय। CVS फ़ाइल-आधारित परिवर्तनों की सूची के रूप में जानकारी संग्रहीत करता है। सीवीएस के लिए सूचना फाइलों का एक समूह है और समय के साथ प्रत्येक फ़ाइल में किए गए परिवर्तन हैं।

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

ये 2 लेख मेरे लिए मददगार थे:

git मान लेना-अपरिवर्तित बनाम स्किप-वर्कट्री और साथ ट्रैक की गई फ़ाइलों में परिवर्तन को अनदेखा करने कैसे अनदेखा करने के लिए git

इस पर आधारित मैं निम्नलिखित कार्य करता हूं, यदि फ़ाइल पहले से ही ट्रैक है:

git update-index --skip-worktree <file>

इस क्षण से इस फ़ाइल में सभी स्थानीय परिवर्तनों को अनदेखा कर दिया जाएगा और रिमोट पर नहीं जाएगा। यदि फ़ाइल रिमोट पर बदल दी जाती है, तो संघर्ष कम हो जाएगा, जब git pull। काम नहीं करेगा। इसे हल करने के लिए, फ़ाइल सामग्री को सुरक्षित स्थान पर कॉपी करें और इन चरणों का पालन करें:

git update-index --no-skip-worktree <file>
git stash
git pull 

फ़ाइल सामग्री को दूरस्थ सामग्री से बदल दिया जाएगा। सुरक्षित स्थान से फाइल करने और फिर से प्रदर्शन करने के लिए अपने परिवर्तन चिपकाएँ:

git update-index --skip-worktree <file>

यदि हर कोई, जो परियोजना के साथ काम करता है, तो प्रदर्शन करेगा git update-index --skip-worktree <file>, समस्याओं के साथpull अनुपस्थित होना चाहिए। यह समाधान कॉन्फ़िगरेशन फ़ाइलों के लिए ठीक है, जब प्रत्येक डेवलपर का अपना प्रोजेक्ट कॉन्फ़िगरेशन होता है।

यह हर बार करना बहुत सुविधाजनक नहीं है, जब फ़ाइल को रिमोट पर बदल दिया गया है, लेकिन इसे दूरस्थ सामग्री द्वारा ओवरराइटिंग से बचा सकता है।

Answer 13

नीचे दिए गए चरणों को क्रम से करें, आप ठीक हो जाएंगे।

1. डायरेक्टरी / स्टोरेज से गलती से जोड़े गए फाइल्स को हटा दें । आप "rm -r" (लिनक्स के लिए) कमांड का उपयोग कर सकते हैं या निर्देशिकाओं को ब्राउज़ करके उन्हें हटा सकते हैं। या उन्हें अपने पीसी पर किसी अन्य स्थान पर ले जाएं। यदि आपको मूविंग / रिमूवल के लिए दौड़ना हो तो आपको IDE को बंद करना होगा ]

2. फाइल / निर्देशिकाओं को gitignoreअब फाइल करने और सहेजने के लिए रखें।

3. इन आदेशों का उपयोग करके उन्हें git कैश से हटा दें (यदि एक से अधिक निर्देशिका हैं, तो उन्हें एक-एक करके बार-बार यह आदेश जारी करके हटा दें)

git rm -r --cached path-to-those-files

4. अब कर एक प्रतिबद्ध और धक्का , इन आदेशों का उपयोग। यह उन फ़ाइलों को git रिमोट से हटा देगा और git को उन फ़ाइलों को ट्रैक करना बंद कर देगा।

git add .
git commit -m "removed unnecessary files from git"
git push origin

Answer 14

कॉपी / पेस्ट का जवाब है git rm --cached -r .; git add .; git status

यह कमांड उन फाइलों को नजरअंदाज कर देगा जो पहले से ही Git रिपॉजिटरी के लिए प्रतिबद्ध हैं लेकिन अब हमने उन्हें इसमें जोड़ा है .gitignore।

Answer 15

मैट फियर का जवाब सबसे प्रभावी IMHO था। निम्नलिखित केवल विंडोज़ में उन लोगों के लिए एक PowerShell स्क्रिप्ट है जो केवल उनके git रेपो से फ़ाइलों को हटाने के लिए है जो उनकी बहिष्करण सूची से मेल खाती है।

# Get files matching exclusionsfrom .gitignore
# Excluding comments and empty lines
$ignoreFiles =  gc .gitignore | ?{$_ -notmatch  "#"} |  ?{$_ -match  "\S"} | % {
                    $ignore = "*" + $_ + "*"
                    (gci -r -i $ignore).FullName
                }
$ignoreFiles = $ignoreFiles| ?{$_ -match  "\S"}

# Remove each of these file from Git 
$ignoreFiles | % { git rm $_}

git add .

Comments

किस स्थिति में फ़ाइलों की यह सूची पुनरावर्ती - कैशेड के बराबर नहीं होगी?

— जॉन ज़ब्रोस्की

Answer 16

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

Comments

git rm --cachedफ़ाइल को डिस्क से हटाए बिना इंडेक्स से हटा देगा, इसलिए इसे स्थानांतरित करने / कॉपी करने की कोई आवश्यकता नहीं है

— bdonlan

Answer 17

git rm --cachedआदेश का उपयोग मूल प्रश्न का उत्तर नहीं देता है:

आप git[एक फ़ाइल] के बारे में पूरी तरह से भूलने के लिए कैसे मजबूर करते हैं ?

वास्तव में, यह समाधान फ़ाइल को रिपॉजिटरी के हर दूसरे इंस्टेंस में डिलीट करने का कारण बनेगाgit pull !

GitHub द्वारा किसी फ़ाइल के बारे में भूलने के लिए git को बाध्य करने का सही तरीका यहाँ दिया गया है ।

मैं प्रलेखन पढ़ने की सलाह देता हूं, लेकिन मूल रूप से:

git fetch --all
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all
git push origin --force --all
git push origin --force --tags
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

बस full/path/to/fileफ़ाइल के पूर्ण पथ के साथ बदलें । सुनिश्चित करें कि आपने फ़ाइल को अपने साथ जोड़ लिया है.gitignore ।

आपको (अस्थायी रूप से) अपने रिपॉजिटरी में गैर-फास्ट-फ़ॉरवर्ड पुश को अनुमति देने की आवश्यकता होगी , क्योंकि आप अपना गिट इतिहास बदल रहे हैं।

Answer 18

बीएफजी विशेष रूप से, Git रेपोस से बड़ी फ़ाइलों या पासवर्ड जैसी अवांछित डेटा को हटाने के लिए बनाया गया है, तो यह एक सरल ध्वज है कि किसी भी बड़े ऐतिहासिक (नहीं-इन-अपने वर्तमान-लिखें) फ़ाइलें निकाल देंगे है: '--strip-blobs- से भी बड़ा'

$ java -jar bfg.jar --strip-blobs-bigger-than 100M

यदि आप नाम से फाइलें निर्दिष्ट करना चाहते हैं, तो आप वह भी कर सकते हैं:

$ java -jar bfg.jar --delete-files *.mp4

बीएफजी गिट फिल्टर-शाखा की तुलना में 10-1000x तेज है, और आमतौर पर उपयोग करने के लिए बहुत आसान है - पूर्ण उपयोग के निर्देशों और उदाहरणों की जांच करें अधिक विवरण के लिए करें।

स्रोत: https://confluence.atlassian.com/bitbucket/reduce-repository-size-32182266.html

Answer 19

यदि आप CLI का उपयोग नहीं करना चाहते हैं और Windows पर काम कर रहे हैं, तो एक बहुत ही सरल उपाय है TortoiseGit का उपयोग करना , इसमें मेनू में "हटाएं (स्थानीय रखें)" क्रिया है जो ठीक काम करती है।

Answer 20

मुझे जॉनब्र्वे का जवाब पसंद आया लेकिन मेरे पास काम करने के लिए पर्याप्त गंदे निर्देशिका हैं, जो मुझे थोड़ा डराता है, इसलिए यहां मैंने जो किया है:

git config --global alias.exclude-अनदेखा! 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r - cached && git ls-files -z --ignored --exclude-standard | xargs -0 git स्टेज और& git स्टेज .itignoreore && git कमिट-मी "नया gitignore और इंडेक्स से अनदेखा फ़ाइलों को हटाएं" '

इसे तोड़ना:

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached 
git ls-files -z --ignored --exclude-standard | xargs -0 git stage 
git stage .gitignore 
git commit -m "new gitignore and remove ignored files from index"

• अनुक्रमणिका से उपेक्षित फ़ाइलों को हटा दें
• चरण .gitignore और आपके द्वारा अभी निकाली गई फ़ाइलें
• प्रतिबद्ध

Answer 21

यह अब नवीनतम git (लेखन के समय v2.17.1) में कोई समस्या नहीं है ।

.gitignoreअंत में पता लगाया बल्कि नष्ट कर दिया उपेक्षा फ़ाइलें। आप निम्न स्क्रिप्ट चलाकर अपने लिए यह परीक्षण कर सकते हैं। अंतिम git statusकथन "कुछ भी नहीं करने के लिए" रिपोर्ट करना चाहिए।

# Create empty repo
mkdir gitignore-test
cd gitignore-test
git init

# Create a file and commit it
echo "hello" > file
git add file
git commit -m initial

# Add the file to gitignore and commit
echo "file" > .gitignore
git add .gitignore
git commit -m gitignore

# Remove the file and commit
git rm file
git commit -m "removed file"

# Reintroduce the file and check status.
# .gitignore is now respected - status reports "nothing to commit".
echo "hello" > file
git status

Comments

मुझे खुशी है कि अब मैं ऐसा करता हूं। हालाँकि, ओपी .ignignore में मौजूद फाइलों में संशोधनों को ट्रैक नहीं करने के बारे में पूछ रहा था, हटाए गए फ़ाइलों को अभी भी एक स्थिति नहीं दिखा रहा है।

— मर्टर्टल

Answer 22

पहले से ही प्रतिबद्ध के मामले में DS_Store:

find . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch

उन्हें अनदेखा करें:

echo ".DS_Store" >> ~/.gitignore_global
echo "._.DS_Store" >> ~/.gitignore_global
echo "**/.DS_Store" >> ~/.gitignore_global
echo "**/._.DS_Store" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

अंत में, कमिट करें!

Answer 23

विशेष रूप से आईडीई आधारित फाइलों के लिए, मैं इसका उपयोग करता हूं:

उदाहरण के लिए slnx.sqlite, मैं अभी पूरी तरह से इसे दूर करने के लिए निम्नलिखित की तरह है:

git rm {PATH_OF_THE_FILE}/slnx.sqlite -f
git commit -m "remove slnx.sqlite"

बस ध्यान रखें कि उन फ़ाइलों में से कुछ परियोजनाओं के लिए कुछ स्थानीय उपयोगकर्ता सेटिंग्स और वरीयताओं को संग्रहीत करता है (जैसे कि आपके पास कौन सी फाइलें खुली थीं)। इसलिए हर बार जब आप नेविगेट करते हैं या अपने IDE में कुछ बदलाव करते हैं, तो वह फ़ाइल बदल दी जाती है और इसलिए यह उसे चेक करती है और दिखाती है कि अनपेक्षित परिवर्तन हैं।

Answer 24

स्वीकृत उत्तर किसी फ़ाइल के बारे में " गिट " को "भूल" नहीं करता है ... "(ऐतिहासिक रूप से)। यह केवल गिट की अनदेखी करता है वर्तमान / भविष्य में फ़ाइल की करता है।

यह विधि पूरी तरह से उपेक्षित फ़ाइलों ( भूत / वर्तमान / भविष्य) को भूल जाती है , लेकिन ऐसा नहीं करती है कार्यशील निर्देशिका (भले ही रिमोट से दोबारा खींची गई) से कुछ भी हटाती है।

इस विधि के उपयोग की आवश्यकता है /.git/info/exclude(पसंदीदा) या एक पूर्व मौजूदा .gitignore में सब करता है कि फ़ाइलों को नजरअंदाज किया जा करने के लिए / भूल। ¹

प्रभावी रूप से इतिहास को प्रभावी रूप से फिर से लिखने के बाद git को लागू करने के सभी तरीकों में उपेक्षा होती है और इस तरह किसी भी सार्वजनिक / साझा / सहयोगी प्रतिनिधि के लिए महत्वपूर्ण प्रभाव पड़ता है जिसे इस प्रक्रिया के बाद खींचा जा सकता है। ²

सामान्य सलाह: एक साफ रेपो के साथ शुरू करें - सब कुछ प्रतिबद्ध, कार्यशील निर्देशिका या सूचकांक में लंबित कुछ भी नहीं, और एक बैकअप बनाएं !

इसके अलावा, टिप्पणी / संशोधन इतिहास के इस जवाब ( और संशोधन इतिहास के इस सवाल का ) ज्ञानवर्धक / उपयोगी हो सकता है।

#commit up-to-date .gitignore (if not already existing)
#this command must be run on each branch

git add .gitignore
git commit -m "Create .gitignore"

#apply standard git ignore behavior only to current index, not working directory (--cached)
#if this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist
#this command must be run on each branch

git ls-files -z --ignored --exclude-standard | xargs -0 git rm --cached

#Commit to prevent working directory data loss!
#this commit will be automatically deleted by the --prune-empty flag in the following command
#this command must be run on each branch

git commit -m "ignored index"

#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)
#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above
#This step will also delete any "empty" commits.  If deliberate "empty" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command

git filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all

#List all still-existing files that are now ignored properly
#if this command returns nothing, it's time to restore from backup and start over
#this command must be run on each branch

git ls-files --other --ignored --exclude-standard

---

अंत में, इस गीथहब गाइड (चरण 6 पर शुरू) के बाकी हिस्सों का पालन करें जिसमें नीचे दिए गए आदेशों के बारे में महत्वपूर्ण चेतावनी / जानकारी शामिल है ।

git push origin --force --all
git push origin --force --tags
git for-each-ref --format="delete %(refname)" refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

---

अन्य देवता जो अब संशोधित रिमोट रेपो से खींचते हैं, उन्हें एक बैकअप बनाना चाहिए और फिर:

#fetch modified remote

git fetch --all

#"Pull" changes WITHOUT deleting newly-ignored files from working directory
#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed

git reset FETCH_HEAD

---

फुटनोट

¹ क्योंकि /.git/info/excludeउपरोक्त निर्देशों का उपयोग करके सभी ऐतिहासिक कमिटों पर लागू किया जा सकता है, शायद ऐतिहासिक कमिट (एस) में एक .gitignoreफ़ाइल प्राप्त करने के बारे में विवरण जो इसकी आवश्यकता है वह इस उत्तर के दायरे से परे है। मैं रूट कमिटमेंट में होना चाहता था , जैसे कि यह पहली चीज थी। दूसरों की परवाह नहीं कर सकते हैं के बाद से एक ही बात पर ध्यान दिए बिना जहां पूरा कर सकते हैं के लिए प्रतिबद्ध इतिहास में मौजूद है, और स्पष्ट रूप से फिर से लिखकर इतिहास एक है बहुत भावुक विषय, तब भी जब के बारे में पता असर.gitignore/.git/info/exclude.gitignore ।

FWIW, संभावित तरीकों में शामिल हो सकता है git rebaseया जो प्रत्येक बाहरी को इस प्रश्न के उत्तर की तरह git filter-branchकॉपी करता है .gitignore

² एक स्टैंडअलोन git rm --cachedकमांड के परिणामों को लागू करने के बाद व्यवहार को नजरअंदाज करने वाले व्यवहार को लागू करना भविष्य में बल-धकेलने वाले रिमोट से नई-उपेक्षित फ़ाइल को हटाने में परिणाम हो सकता है । --prune-emptyनिम्नलिखित में झंडा git filter-branchआदेश स्वचालित रूप से हटाने के पिछले "सब पर ध्यान नहीं दिया फ़ाइलों को हटाने" अनुक्रमणिका-केवल प्रतिबद्ध करके इस समस्या से बचा जाता है। रीट राइटिंग गिट हिस्ट्री भी कमिट हैश को बदल देती है, जो पब्लिक / शेयर्ड / कोऑपरेटिव रिपोज से भविष्य में आने वाले कहर पर कहर बरपाएगा। कृपया समझें असर पूरी तरह से इस तरह के एक रेपो को ऐसा करने से पहले। यह GitHub गाइड निम्नलिखित निर्दिष्ट करता है:

अपने सहयोगियों को रिबेज करने के लिए कहें , मर्ज न करें , किसी भी शाखा को उन्होंने आपके पुराने (दागी) भंडार इतिहास से दूर कर दिया। एक मर्ज कमिटमेंट कुछ या सभी दागी इतिहास को फिर से प्रस्तुत कर सकता है जिसे आप सिर्फ शुद्ध करने की परेशानी में गए थे।

वैकल्पिक समाधान जो दूरस्थ रेपो को प्रभावित नहीं करते हैं git update-index --assume-unchanged </path/file>या git update-index --skip-worktree <file>, जिनके उदाहरण यहां मिल सकते हैं ।

Answer 25

यदि किसी के पास विंडोज पर कठिन समय है और आप संपूर्ण फ़ोल्डर को अनदेखा करना चाहते हैं, तो 'फ़ोल्डर' को वांछित करने के लिए 'सीडी' और 'गेट बैश हियर' करें।

git ls-files -z | xargs -0 git update-index --assume-unchanged

Answer 26

मेरे मामले में, मेरे पास कई निर्देशिकाओं में कई .lock फाइलें थीं जिन्हें मुझे हटाने की आवश्यकता थी। मैं निम्नलिखित भाग गया और इसे हटाने के लिए प्रत्येक निर्देशिका में जाने के बिना काम किया:

git rm -r --cached **/*.lock

ऐसा करना प्रत्येक फ़ोल्डर में 'रूट' के तहत गया जहां मैं था और पैटर्न से मेल खाने वाली सभी फ़ाइलों को बाहर कर दिया।

आशा है कि यह दूसरों की मदद करता है!