3067

मैं अपनी शाखा में केवल एक से अधिक परिवर्तित फ़ाइलों को कैसे मिटा सकता हूं?

git git-stash

109

मुझे नहीं लगता कि @ bukzor का स्वीकृत उत्तर प्रश्न का एक सही उत्तर है क्योंकि यह पूछा गया था। git stash --keep-indexसूचकांक रखता है, लेकिन यह सब कुछ चुराता है - सूचकांक और बाहर दोनों।

— रमन

@Antonio मुझे ऐसा लगता है कि आपके बाउंटी को वास्तव में एक अलग प्रश्न होना चाहिए, क्योंकि मूल प्रश्न का कछुआगेट से विशेष रूप से कोई लेना-देना नहीं है।

— जीससफ्रेके

1

@JesusFreke हां, यह देखते हुए कि मैं 50 प्रतिनिधि बख्शा जा सकता है :) यह सिर्फ इतना है कि यदि आप "आंशिक स् टॉस टॉइज़िट" की खोज करने की कोशिश करते हैं तो यह सवाल है। Tortoisegit एक लोकप्रिय विषय नहीं लगता है यहाँ stackoverflow.com/questions/tagged/tortoisegit

— एंटोनियो

7

>>>>>>>>> git diff -- *filename* > ~/patchतब git checkout -- *filename*और बाद में आप पैच को फिर से लागू कर सकते हैंgit apply ~/patch

— neaumusic

36

नीचे दिए गए अधिकांश मौजूदा उत्तर पुराने हैं। Git 2.13 (Q2 2017) के बाद से यह समर्थित है git stash push [--] [<pathspec>...]।

— ओहद श्नाइडर

1372

डिस्क्लेमर : निम्नलिखित उत्तर git 2.13 से पहले git के लिए है। 2.13 और उससे अधिक के लिए, नीचे एक और उत्तर देखें ।

चेतावनी

जैसा कि टिप्पणियों में कहा गया है, यह सब कुछ मंच पर रखता है, दोनों मंचन और अस्थिर। - Thekeep-index बस स्टैश किए जाने के बाद इंडेक्स को अकेला छोड़ देता है। जब आप बाद में स्टैश पॉप करते हैं तो इससे मर्ज टकराव हो सकता है।

यह सब कुछ है कि आप पहले नहीं जोड़ा है संघर्ष होगा। बस git addजो चीजें आप रखना चाहते हैं, उसे चलाएं।

git stash --keep-index

उदाहरण के लिए, यदि आप एक पुराने कमिट को एक से अधिक बदलावों में विभाजित करना चाहते हैं, तो आप इस प्रक्रिया का उपयोग कर सकते हैं:

git rebase -i <last good commit>
कुछ बदलावों को चिह्नित करें edit।
git reset HEAD^
git add <files you want to keep in this change>
git stash --keep-index
आवश्यकतानुसार चीजों को ठीक करें। git addकिसी भी बदलाव के लिए मत भूलना ।
git commit
git stash pop
आवश्यकतानुसार # 5 से दोहराएं।
git rebase --continue

— bukzor
स्रोत

47

मुझे यह तरीका बहुत अधिक सरल लगता है: stackoverflow.com/a/5506483/457268

— k0pernikus

561

मुझे यकीन नहीं है कि इसे क्यों उखाड़ा जा रहा है। सभी को मुझसे अलग उम्मीद करनी चाहिए। मूल पोस्ट पूछ रही है "मैं बिना किसी परिवर्तन के सिर्फ एक हिस्से को कैसे मिटा सकता हूं?" जब मैं उपयोग करता हूं git stash save -k, हां सूचकांक (हरा git stat) इन संरक्षित है, लेकिन संपूर्ण परिवर्तन (हरा और लाल दोनों) स्‍टैश में चला जाता है। यह ओपी के अनुरोध का उल्लंघन करता है, "केवल कुछ परिवर्तनों को रोकें"। मैं सिर्फ कुछ लाल (भविष्य के उपयोग के लिए) को स्टैश करना चाहता हूं।

— पिस्तोस

70

यदि आप @Pistos (जैसा कि मैं था) द्वारा पूछे गए प्रश्न के उत्तर में अधिक रुचि रखते हैं, तो यहां देखें: stackoverflow.com/questions/5506339/…

— रमन

27

@ रामन: बहुत बढ़िया! git stash -pवास्तव में मैं क्या देख रहा था। मुझे आश्चर्य है कि अगर यह स्विच हाल ही में जोड़ा गया था।

— पिस्टन

14

चेतावनी: git stash --keep-indexटूट गया है। यदि आप अधिक परिवर्तन करते हैं, तो git stash popबाद में आप मर्ज संघर्ष प्राप्त करने का प्रयास करें क्योंकि स्टैश में आपके द्वारा रखी गई परिवर्तित फाइलें शामिल हैं, न कि केवल वे जिन्हें आपने नहीं रखा था। उदाहरण के लिए: मैं फ़ाइलों को ए और बी में बदलता हूं, फिर बी को रोक देता हूं, क्योंकि मैं ए में बदलाव का परीक्षण करना चाहता हूं; मुझे ए के साथ एक समस्या मिलती है जो मैं तब ठीक करता हूं; मैं ए; अब मैं अस्थिर नहीं कर सकता क्योंकि A का एक पुराना संस्करण बिना किसी अच्छे कारण के मर्ज में टकराव का कारण है। व्यवहार में A और B कई फाइलें हो सकती हैं, शायद बाइनरी इमेज या कुछ भी, इसलिए मुझे मूल रूप से बी को देना होगा और हारना होगा

— rjmunro

3014

आप भी उपयोग कर सकते हैं git stash save -p "my commit message" । इस तरह से आप यह चुन सकते हैं कि स्लैश में कौन-सी हंक जोड़ी जानी चाहिए, पूरी फ़ाइलों को भी चुना जा सकता है।

आपको प्रत्येक हंक के लिए कुछ कार्यों से प्रेरित किया जाएगा:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

— konrad.kruczynski
स्रोत

5

यह नहीं था। यह तथ्य के लगभग 7 साल बाद, डार्क्स से उधार लिया गया था।

— nomen

6

मैं एक TortoiseGit की दीवानी हूं। हालांकि TortoiseGit समर्थन नहीं करता है stash -p। मैं यह जवाब देता हूं क्योंकि यह सबसे अधिक इंटरैक्टिव / उपयोगकर्ता के अनुकूल है।

— एंटोनियो

27

आप जोड़ना चाहते हैं हो सकता है: git stash save -p my stash message; चूंकि आर्गुमेन्स्ट का आदेश बहुत सहज नहीं है ...

— क्रिस मेस

15

इस और के बीच git log -p, मुझे लगता है कि -pध्वज का मतलब "ठंडी चीज है जो मैं चाहता हूं, लेकिन व्यक्त करना नहीं जानता।"

— काइल स्ट्रैंड

2

क्यों पृथ्वी पर यह महान उत्तर 12 वें स्थान पर है ?? उन सभी 0, +1, +2 उत्तरों के बाद ??????

— डेनिसफ्लेश

546

चूँकि git मूल रूप से सभी रिपॉजिटरी सामग्री और इंडेक्स (और एक या कई फाइलें नहीं) के प्रबंधन के बारे में है ,git stash सौदों, आश्चर्यजनक रूप से , नहीं~~सभी कार्यशील निर्देशिका के साथ~~।

दरअसल, Git 2.13 (Q2 2017) के बाद से, आप अलग-अलग फ़ाइलों को स्टैश कर सकते हैं git stash push:

git stash push [--] [<pathspec>...]

जब pathspec' git stash push' को दिया जाता है , तो नया स्टैश केवल उन फ़ाइलों के लिए संशोधित स्टेट्स को रिकॉर्ड करता है जो कि pathspec से मेल खाती हैं "अधिक के लिए" विशिष्ट फ़ाइलों में परिवर्तन देखें " ।

सरलीकृत उदाहरण:

 git stash push path/to/file

इस सुविधा का परीक्षण मामला कुछ और विकल्प दिखाता है:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

मूल उत्तर (नीचे, जून 2010) मैन्युअल रूप से चुनने के बारे में था कि आप क्या करना चाहते हैं।

Casebash टिप्पणियाँ:

यह ( stash --patchमूल समाधान) अच्छा है, लेकिन अक्सर मैंने बहुत सारी फ़ाइलों को संशोधित किया है ताकि पैच का उपयोग करना कष्टप्रद हो

bukzor का उत्तर ( उत्कीर्ण , नवंबर 2011)
git add+ केgit stash --keep-index आधार पर एक अधिक व्यावहारिक समाधान सुझाता है ।
देखते हैं और उसके उत्तर को बढ़ाते हैं, जो आधिकारिक होना चाहिए (मेरी बजाय)।

उस विकल्प के बारे में, chhh टिप्पणी में एक वैकल्पिक वर्कफ़्लो बताते हैं:

आपको git reset --softअपना स्पष्ट मंचन वापस पाने के लिए इस तरह के संघर्ष के बाद ": "
मूल स्थिति में आने के लिए - जो कि एक स्पष्ट मंचन क्षेत्र है और केवल कुछ चुनिंदा गैर-चरणबद्ध संशोधनों के साथ, कोई भी धीरे-धीरे अनुक्रमणिका को रीसेट कर सकता है (बिना इसके बिना) आप जैसा कुछ भी करना - bukzor - did)।

(मूल उत्तर जून 2010: मैनुअल स्टैश)

फिर भी, git stash save --patchआप अपने द्वारा किए जा रहे आंशिक संघर्ष को प्राप्त करने की अनुमति दे सकते हैं:

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

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

git stash --patch --no-keep-index

एक बेहतर फिट हो सकता है।

यदि --patchकाम नहीं करता है, तो एक मैनुअल प्रक्रिया हो सकती है:

एक या कई फाइलों के लिए, एक मध्यवर्ती समाधान निम्नलिखित होगा:

Git रेपो के बाहर उन्हें कॉपी करें
(वास्तव में, एटलोट्राम एक दिलचस्प विकल्प प्रस्तावित करता है )
git stash
उन्हें वापस कॉपी करें
git stash # इस समय, केवल वे फ़ाइलें जिन्हें आप चाहते हैं, वे स्टैक्ड हैं
git stash pop stash@{1} # अपनी सभी फाइलों के संशोधनों को फिर से लागू करें
git checkout -- afile # किसी भी स्थानीय संशोधनों से पहले फ़ाइल को HEAD सामग्री पर रीसेट करें

उस बल्कि बोझिल प्रक्रिया के अंत में, आपके पास केवल एक या कई फाइलें होंगी।

— VonC
स्रोत

3

यह अच्छा है, लेकिन अक्सर मैंने बहुत सारी फ़ाइलों को संशोधित किया है ताकि पैच का उपयोग करना कष्टप्रद हो

— केसबश

6

@VonC: प्रति उत्तर केवल एक उत्तर होना अच्छी शैली है। इसके अलावा, दूसरों के उत्तरों को अपने आप में कॉपी-पेस्ट करना बुरा व्यवहार है।

— bukzor

3

@ बुकजोर: मुझे खेद है अगर मेरा संपादित उत्तर अनुचित लगा। मेरा एकमात्र उद्देश्य आपके उत्तर को अधिक दृश्यता देना था। मैंने उस इरादे को स्पष्ट करने के लिए अपनी पोस्ट को फिर से संपादित किया है।

— VonC

1

@ काल: सच, stackoverflow.com/a/13941132/6309 एक git reset(मिश्रित) का सुझाव देता है

— VonC

3

git is fundamentally about managing a all repository content and index and not one or several files- इस समस्या को हल किया जा रहा है कि निगरानी के कार्यान्वयन; यह एक स्पष्टीकरण है, लेकिन औचित्य नहीं है। कोई भी स्रोत नियंत्रण प्रणाली "कई फाइलों के प्रबंधन" के बारे में है। जरा देखिए क्या टिप्पणी सबसे ऊपर उठती है।

— विक्टर सर्जेनको

90

जब git stash -p(या git add -pसाथ stash --keep-index) बहुत बोझिल हो जाएगा, मैं इसे उपयोग करने के लिए आसान पाया diff, checkoutऔरapply :

किसी विशेष फ़ाइल को केवल "स्टैश" करने के लिए:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

फिर बाद में

git apply stashed.diff

— blueyed
स्रोत

1

git add -pउपरोक्त मेरे स्वयं के उत्तर में वर्णित दिलचस्प विकल्प । +1।

— VonC

11

ध्यान दें कि यदि आपके पास बाइनरी फाइलें (पीएनजी की तरह) हैं, तो वे अलग फ़ाइल में आउटपुट नहीं होंगे। तो यह 100% समाधान नहीं है।

— void.pointer

1

@ रोबर्टडेली: यह मेरे लिए एक दिलचस्प बिंदु है, क्योंकि git diff > file.diffऔर git applyमेरे सामान्य आंशिक उपकरण हैं। मुझे git stash -pबड़े बदलाव के लिए स्विच करने पर विचार करना पड़ सकता है ।

— वाकिंगट्रूथ

1

@thekingoftruth यहाँ मैं पैच फाइल बनाने के लिए उपयोग किया गया उपनाम है, और यह बायनेरिज़ का समर्थन करता हैpatch = log --pretty=email --patch-with-stat --reverse --full-index --binary :। ध्यान दें, हालांकि, पैच के लिए आपके बदलाव के लिए प्रतिबद्ध होना आवश्यक है।

— void.pointer

2

यह मेरे लिए साफ-सुथरा काम नहीं कर रहा था अगर फाइल को स्टैश करना कुछ ऐसा था ../../foo/bar.txt। पैच ठीक उत्पन्न करता है, लेकिन मुझे पैच लागू करने के लिए रिपॉजिटरी रूट पर जाने की आवश्यकता है। इसलिए यदि आप इससे परेशान हैं - तो सुनिश्चित करें कि आप इसे रिपॉजिटरी रूट डायरेक्टरी से कर रहे हैं।

— माइकल एंडरसन

86

git stash pushइस तरह का उपयोग करें:

git stash push [--] [<pathspec>...]

उदाहरण के लिए:

git stash push -- my/file.sh

यह वसंत 2017 में रिलीज़ किए गए Git 2.13 के बाद से उपलब्ध है।

— Sandstrom
स्रोत

1

लेकिन मैं अपने जवाबgit stash push में पहले से ही पिछले महीने 5 मार्च से पहले उल्लेख करता हूं । और मैंने उस नए Git 2.13 कमांड को यहां विस्तृत किया: stackoverflow.com/a/42963606/6309 ।

— VonC

मुझे खुशी है कि Git इतनी जल्दी आगे बढ़ रहा है, लंबे समय तक यह संभव नहीं था और फिर 2.13 जारी किया गया और अचानक एक सरल समाधान उपलब्ध है!

— सैंडस्ट्रॉम

1

@VonC आप सही हैं, आप सही उत्तर का भी उल्लेख करते हैं, हालांकि, दो उत्तरों के बीच, यह पढ़ना आसान है (कोई भ्रमित पाठ नहीं है और एक उदाहरण भी है)। हो सकता है कि उन्होंने आपके जवाब को संपादित किया हो

— Utopik

@ यूटोपिक आपने मुझे "आप सही कह रहे हैं" ... लेकिन हां, मैंने एक उदाहरण को शामिल करने के लिए अपना जवाब संपादित किया है।

— VonC

क्या एक तब git stash applyस्टैक्ड परिवर्तनों को पुनर्प्राप्त करने के लिए उपयोग करता है ?

— चाड

49

मान लीजिए कि आपके पास 3 फाइलें हैं

a.rb
b.rb
c.rb

और आप केवल b.rb और c.rb को स्ट्रैश करना चाहते हैं लेकिन a.rb को नहीं

आप ऐसा कुछ कर सकते हैं

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

और आप कर रहे हैं! HTH।

— venkatareddy
स्रोत

29

ऐसा करने का एक और तरीका:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

मैं इस पृष्ठ के बाद (एक बार फिर) इस पृष्ठ पर आया और पहले दो उत्तरों को पसंद नहीं किया (पहला उत्तर सिर्फ प्रश्न का उत्तर नहीं देता है और मुझे -pइंटरेक्टिव मोड के साथ काम करना पसंद नहीं है)।

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

— सूर्यकांत मणि
स्रोत

1

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

— मार्क Ch

एसओ का उपयोग करते हुए पदों पर उत्तरों का उल्लेख करना उचित नहीं है। रेटिंग बदलते ही पद बदल जाते हैं।

— ब्रायन ऐश

2

@BryanAsh खैर, यह यहाँ की तरह मायने नहीं रखता। मैं वास्तव में अन्य उत्तरों का संदर्भ देने के बजाय एक किस्सा दे रहा हूं। संदेश यह है कि मुझे उन उत्तरों को पसंद नहीं आया जो समुदाय को पसंद थे और न कि इन उत्तरों में वास्तव में क्या हैं। इसके अलावा, दूसरे और तीसरे उत्तर के बीच 900 वोट का अंतर निकट भविष्य में इसे बदलने की संभावना नहीं है, और अगर इसे कभी बदलना चाहिए, तो मैं इसे "समय पर जवाब देने के लिए शीर्ष" कहने के लिए हमेशा संपादित कर सकता हूं। वास्तव में, मैं यह नहीं देखता कि इस स्थिति में यह किसी प्रकार की समस्या कैसे है।

— जैस्पर

23

अद्यतन (2/14/2015) - मैंने स्क्रिप्ट को फिर से लिखा है, संघर्षों के मामले को बेहतर ढंग से संभालने के लिए, जिसे अब .rej फ़ाइलों के बजाय अनमोल संघर्षों के रूप में प्रस्तुत किया जाना चाहिए।

मुझे अक्सर @ bukzor के दृष्टिकोण का उलटा करना अधिक सहज लगता है। यही है, कुछ परिवर्तनों को चरणबद्ध करना, और उसके बाद केवल उन परिवर्तनों को रोकना।

दुर्भाग्य से, git एक git stash --only-index या इसी तरह की पेशकश नहीं करता है, इसलिए मैंने ऐसा करने के लिए एक स्क्रिप्ट को कोड़ा।

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

आप उपरोक्त स्क्रिप्ट को git-stash-indexअपने पथ पर कहीं भी सहेज सकते हैं , और फिर इसे git stash-index के रूप में लागू कर सकते हैं

# <hack hack hack>
git add <files that you want to stash>
git stash-index

अब स्टैश में एक नई प्रविष्टि है जिसमें केवल आपके द्वारा किए गए परिवर्तनों को शामिल किया गया है, और आपके काम करने वाले पेड़ में अभी भी कोई भी अस्थिर परिवर्तन नहीं है।

कुछ मामलों में, कार्यशील वृक्ष परिवर्तन सूचकांक परिवर्तनों पर निर्भर हो सकते हैं, इसलिए जब आप सूचकांक परिवर्तनों को रोकते हैं, तो कार्यशील वृक्ष परिवर्तनों में विरोध होता है। इस स्थिति में, आपको सामान्य अनमैरिड उलझनें मिलेंगी जिन्हें आप git merge / git mergetool / etc के साथ हल कर सकते हैं।

— JesusFreke
स्रोत

स्क्रिप्ट के अंत pushdमें cdऔर उसके बजाय अनुशंसा popdकरें यदि स्क्रिप्ट सफल हो जाती है, तो उपयोगकर्ता को चलाने से पहले उसी निर्देशिका में समाप्त होता है।

— नैट

1

@ पता: जहां तक मुझे पता है, यह केवल उपयोगकर्ता के लिए निर्देशिका को बदलना चाहिए, यदि वे स्क्रिप्ट में खटास लाते हैं। यदि आप स्क्रिप्ट को सामान्य रूप से चलाते हैं (~ / bin / git-stash-index), या git (git stash-index) के माध्यम से, यह एक अलग टर्मिनल सत्र में चलता है, और उस सत्र में कोई भी कार्यशील निर्देशिका परिवर्तन प्रभावित नहीं करते हैं उपयोगकर्ता के टर्मिनल सत्र में कार्यशील निर्देशिका। क्या आप एक सामान्य उपयोग के मामले से अवगत हैं जब यह सच नहीं है? (स्क्रिप्ट सोर्स करने के अलावा, जिसे मैं "आम" नहीं

— मानूंगा

20

यदि आप अपने स्टैक्ड परिवर्तनों के साथ कोई संदेश निर्दिष्ट नहीं करना चाहते हैं, तो डबल-डैश के बाद फ़ाइलनाम पास करें।

$ git stash -- filename.ext

यदि यह एक अनट्रैक / नई फ़ाइल है, तो आपको इसे पहले चरण में लाना होगा।

यह विधि git संस्करणों में काम करती है 2.13+

— sealocal
स्रोत

वह उत्तर क्रिया है, यह संक्षिप्त है। अगर यह किसी की मदद करता है, तो मैं इसे छोड़ दूंगा। इस पृष्ठ पर किसी ने इस वाक्यविन्यास और परिणाम का उल्लेख नहीं किया है - वे इसके बजाय `गिट स्टश पुश` का उल्लेख करते हैं।

— सीलोक

यह वह उत्तर है जिसकी मुझे तलाश थी। धन्यवाद! +1

— निकोडप

19

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

— shangxiao
स्रोत

2

आप बिना संपादन वाले शाखा नहीं बना सकते। आप सभी संपादनों को आसानी से एक नई शाखा में ले जा सकते हैं (स्टैश / स्टैश पॉप), लेकिन फिर आप एक वर्ग में वापस आ जाएंगे : आप अपनी शाखा का परीक्षण केवल कुछ संपादनों के साथ कैसे कर सकते हैं, दूसरों को खोए बिना?

— bukzor

7

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

— आईएन

3

@ यदि आप स्थानीय परिवर्तन करते हैं, तो आप शाखाओं को बदल सकते हैं, जब तक कि उन्हें मर्ज की आवश्यकता न हो। देखें उदाहरण सार । यह कम से कम Git v2.7.0 के रूप में सच है।

— कॉलिन डी बेनेट

18

आप बस यह कर सकते हैं:

git stash push "filename"

या एक वैकल्पिक संदेश के साथ

git stash push -m "Some message" "filename"

— vinodsaluja
स्रोत

1

यह कोई नई बात नहीं है। Git stash पुश पहले से ही कई उत्तरों में उल्लेखित है

— JesusFreke

12

निम्न कोड को फ़ाइल में सहेजें, उदाहरण के लिए, नाम stash। उपयोग है stash <filename_regex>। फ़ाइल के पूर्ण पथ के लिए तर्क नियमित अभिव्यक्ति है। उदाहरण के लिए, a / b / c.txt, stash a/b/c.txtया stash .*/c.txtआदि को स्‍टैश करने के लिए ।

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

फ़ाइल में कॉपी करने के लिए कोड:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

— खुबानी
स्रोत

2

बड़ी विधि। मैंने उत्तर के रूप में इसे चुना होगा। भविष्य के पाठकों के लिए टिप: आपको पूर्ण पथ पर मेल खाना है। जैसे stash subdir / foo.c

— er0

12

शायद ज़रुरत पड़े तो आप वास्तव में मतलब परिवर्तन छोड़ने की जब भी आप का उपयोग git stash(और वास्तव में यह अस्थायी रूप से छिपाया जा git छिपाने की जगह का उपयोग नहीं करते), उस मामले में आप उपयोग कर सकते हैं

git checkout -- <file>

[ नोट ]

यह git stashब्रांचिंग और सामान करने के लिए सिर्फ एक तेज और सरल विकल्प है।

— देवेश
स्रोत

8

Git रेपो के बाहर फ़ाइलों की प्रतिलिपि बनाने के VonC के `मध्यवर्ती 'समाधान के साथ समस्या यह है कि आप पथ की जानकारी खो देते हैं, जो बाद में कुछ परेशानी होने पर फ़ाइलों का एक गुच्छा कॉपी करना बनाता है।

टार का उपयोग करना आसान लगता है (समान उपकरण संभवतः ऐसा करेंगे) कॉपी के बजाय:

tar cvf /tmp/stash.tar path / to / some / file path / to / some / other / file (... आदि)
git चेकआउट पथ / से / कुछ / फ़ाइल पथ / से / कुछ / अन्य / फ़ाइल
जीआईटी की मार
tar xvf /tmp/stash.tar
आदि (देखें VonC का `इंटरमीडिएट 'सुझाव)

— eleotlecram
स्रोत

checkout -fजरूरत नहीं है, checkout(बिना -f) पर्याप्त है, मैंने जवाब अपडेट कर दिया है।

— एलोटलक्रैम

8

कभी-कभी मैंने अपनी शाखा पर एक असंबंधित परिवर्तन किया है इससे पहले कि मैंने इसे किया है, और मैं इसे दूसरी शाखा में स्थानांतरित करना चाहता हूं और इसे अलग से (जैसे गुरु) करना चाहता हूं। मैं यह करता हूँ:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

ध्यान दें पहले stashऔर stash popसमाप्त किया जा सकता है, आप अपने सभी परिवर्तनों को खत्म कर सकते हैंmaster शाखा में जब आप चेकआउट करते हैं, लेकिन केवल अगर कोई संघर्ष नहीं है। इसके अलावा, यदि आप आंशिक परिवर्तनों के लिए एक नई शाखा बना रहे हैं, तो आपको स्टैश की आवश्यकता होगी।

आप इसे बिना किसी संघर्ष और नई शाखा मान सकते हैं।

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

स्टैश की भी जरूरत नहीं ...

— void.pointer
स्रोत

8

यह SourceTree का उपयोग करके 3 चरणों में आसानी से किया जा सकता है।

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

यह सब SourceTree में सेकंड के एक मामले में किया जा सकता है, जहां आप बस उन फ़ाइलों (या यहां तक कि व्यक्तिगत लाइनों) पर क्लिक कर सकते हैं जिन्हें आप जोड़ना चाहते हैं। एक बार जोड़े जाने के बाद, बस उन्हें एक अस्थायी प्रतिबद्धता के लिए प्रतिबद्ध करें। इसके बाद, सभी परिवर्तनों को जोड़ने के लिए चेकबॉक्स पर क्लिक करें, फिर सबकुछ को छिपाने के लिए स्टैश क्लिक करें। रास्ते से हटे हुए परिवर्तनों के साथ, अपनी प्रतिबद्ध सूची पर नज़र डालें और अपने अस्थायी कमिट से पहले कमिट के लिए हैश को नोट करें, फिर 'git reset hash_b4_temp_commit' चलाएं, जो मूल रूप से आपकी शाखा को रीसेट करके "पॉपिंग" करने जैसा है। इसके ठीक पहले कमिट करें। अब, आप केवल उस सामान के साथ रह गए हैं जिसे आप स्टैन्ड नहीं करना चाहते थे।

— Triynko
स्रोत

8

मैं उपयोग करूंगा git stash save --patch। मुझे अन्तरक्रियाशीलता को कष्टप्रद नहीं लगता क्योंकि इसमें संपूर्ण फ़ाइलों के लिए वांछित संचालन को लागू करने के लिए विकल्प हैं।

— रफ़ी खाचदौरीं
स्रोत

3

हैरान इस जवाब के लिए बहुत कम है, यह एक निबंध के लिए आवश्यकता के बिना सबसे अच्छा समाधान है।

— रोबस्टार्ब

निश्चित रूप से अच्छा जवाब, git stash -pआपको एक पूरी फ़ाइल को तेजी से और बाद में छोड़ने की अनुमति देता है।

— रिचर्ड डेली

7

यहाँ हर उत्तर इतना जटिल है ...

इसके बारे में "स्टैश" करने के लिए:

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

यह फ़ाइल परिवर्तन वापस पॉप करने के लिए:

git apply /tmp/stash.patch

एक ही फ़ाइल को चोरी करने और उसे वापस पॉप करने के समान व्यवहार करें।

— क्रिस्टोफ़ फोंडिएक
स्रोत

मैंने इसे आजमाया लेकिन कुछ नहीं हुआ। जब मेरे git applyपास कोई त्रुटि नहीं होती है, लेकिन परिवर्तन वापस नहीं लाए जाते हैं

— क्लेमेंटवैल्टर

संभवत: आपने / tmp में जो पैच फ़ाइल जनरेट की थी, उसे हटा दिया गया है। आप अंतर और आवेदन के बीच रिबूट हो सकते हैं। एक और अधिक स्थायी स्थान का प्रयास करें। यह वास्तव में कारगर है। पैच फ़ाइल की सामग्री की भी जाँच करें।

— क्रिस्टोफ़ फोंडिएक

4

मैंने इसके लिए उत्तर और टिप्पणियों और इसी तरह के कई थ्रेड्स की समीक्षा की है। ध्यान रखें कि निम्न में से कोई भी आदेश किसी भी विशिष्ट ट्रैक की गई / अनट्रैक की गई फ़ाइलों को हटाने में सक्षम होने के उद्देश्य के लिए सही नहीं हैं :

git stash -p (--patch): अनट्रैक की गई फ़ाइलों को छोड़कर, मैन्युअल रूप से हॉक चुनें
git stash -k (--keep-index): सभी ट्रैक की गई / अनट्रैक की गई फ़ाइलों को स्टैश करें और उन्हें वर्किंग डायरेक्टरी में रखें
git stash -u (--include-untracked): सभी ट्रैक / अनट्रैक की गई फ़ाइलों को स्टैश करें
git stash -p (--patch) -u (--include-untracked): अवैध आदेश

वर्तमान में, किसी भी विशिष्ट ट्रैक्ड / अनट्रैक फ़ाइलों को स्टैच करने में सक्षम होने के लिए सबसे उचित तरीका निम्न है:

उन फ़ाइलों को अस्थायी रूप से कमिट करें, जिन्हें आप स्‍टैश नहीं करना चाहते हैं
जोड़ें और स्लेश करें
अस्थायी प्रतिबद्ध पॉप

मैंने एक अन्य प्रश्न के उत्तर में इस प्रक्रिया के लिए एक सरल स्क्रिप्ट लिखी , और यहां SourceTree में प्रक्रिया को निष्पादित करने के चरण हैं ।

— ZimbiX
स्रोत

4

समाधान

स्थानीय परिवर्तन:

file_A (संशोधित) का मंचन नहीं किया गया
file_B (संशोधित) का मंचन नहीं किया गया
file_C (संशोधित) का मंचन नहीं किया गया

केवल पर परिवर्तन के साथ एक गुप्त कोष "my_stash" बनाने के लिए file_C :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

किया हुआ।

व्याख्या

स्टेजिंग क्षेत्र में file_C जोड़ें
अस्थायी अस्थायी नाम "temp_stash" बनाएं और फाइल_सी पर परिवर्तन रखें
वांछित परिवर्तन ("my_stash") केवल file_C पर परिवर्तन के साथ बनाएँ
अपने स्थानीय कोड पर "temp_stash" (file_A और file_B) में परिवर्तन लागू करें और स्टाश को हटा दें

आप जो चल रहा है उसे देखने के लिए चरणों के बीच git स्थिति का उपयोग कर सकते हैं ।

— एलेक्स 75
स्रोत

3

जब आप दो शाखाओं के बीच स्विच करने का प्रयास करते हैं, तो यह स्थिति होती है।

"का उपयोग करके फ़ाइलें जोड़ने का प्रयास करेंgit add filepath " ।

बाद में इस लाइन को निष्पादित करें

git stash --keep-index

— सिरेश यारलागड्डा
स्रोत

3

किसी एकल फ़ाइल का उपयोग करने के लिए git stash --patch [file] ।

यह शीघ्र करने जा रहा है: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?। बस टाइप करें a(इस हंक को और सभी बाद में फाइल में हंक करें) और आप ठीक हैं।

— विनीसियस ब्रासिल
स्रोत

मिसिंग pushइनgit stash push --patch [file]

— फिलीप ओबोरंडियो

@FilipeEsperandio pushकेवल Git के हाल के संस्करणों में काम करता है, हुआ करता था save। या तो मामले में pushया saveकॉल करके निहित किया जाता है stash: "बिना किसी तर्क के जीआईटी स्टैश कॉलिंग जीआईटी स्टैश पुश के बराबर है", डॉक्स

— पैट्रिक

2

समान स्थिति। किया और महसूस किया कि यह ठीक नहीं है।

git commit -a -m "message"
git log -p

उत्तरों के आधार पर इसने मेरी मदद की।

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

— डेविड हब्रिक
स्रोत

2

इस स्थिति में मैं git add -p(इंटरएक्टिव), git commit -m blahऔर फिर यदि आवश्यक हो तो छोड़ दिया गया है।

— J0hnG4lt
स्रोत

2

मुझे पता नहीं है कि यह कमांड लाइन पर कैसे किया जाता है, केवल SourceTree का उपयोग करके। कहते हैं कि आपने फ़ाइल A को बदल दिया है, और फ़ाइल B में दो परिवर्तन हंक हैं। यदि आप फ़ाइल B में केवल दूसरे हंक को रोकना चाहते हैं और बाकी सब कुछ छोड़ दें, तो यह करें:

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

— जुझास कोंतवानीस
स्रोत

2

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

— celikz
स्रोत

1

ठीक है, आपको ऐसा नहीं करना चाहिए। उत्तर प्रश्न के लिए एक समाधान प्रदान करना चाहिए। आप सिर्फ अपना सवाल पूछ सकते हैं।

— L_J

यह समाधान THIS प्रश्न का सबसे आसान उत्तर है। प्रश्न पढ़ें, सभी उत्तरों और मेरा तुलना करें, अगर आपको कोई संदेह है कि यह उत्तर न तो लागू समाधान है और न ही प्रश्न के बारे में अपर्याप्त जानकारी है, तो हम फिर से बात कर सकते हैं।

— celikz

यह काम नहीं करेगा, क्योंकि तीसरी कमांड, "गिट स्टैश" स्टेज्ड फाइलों का सम्मान नहीं करेगा। दोनों, मंचन और नॉनस्टेज फाइलें स्लैश में जाएंगी। प्रश्न विशेष रूप से पूछते हैं कि केवल एक फ़ाइल को कैसे स्टैश किया जाए

— CyberProdigy

0

एक जटिल तरीका यह होगा कि पहले हम सब कुछ करें:

git add -u
git commit // creates commit with sha-1 A

मूल प्रतिबद्ध पर वापस रीसेट करें, लेकिन नई प्रतिबद्धता से the_one_file चेकआउट करें:

git reset --hard HEAD^
git checkout A path/to/the_one_file

अब आप the_one_file को स्‍टैश कर सकते हैं:

git stash

मूल फ़ाइल पर वापस जाते समय अपनी फ़ाइल प्रणाली में प्रतिबद्ध सामग्री को सहेज कर सफाई करें:

git reset --hard A
git reset --soft HEAD^

हाँ, कुछ अजीब है ...

— मार्टिन जी
स्रोत

0

मुझे कोई जवाब नहीं मिला कि मुझे क्या चाहिए और वह उतना ही आसान है:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

यह ठीक एक फ़ाइल को चुराता है।

— SCBuergel.eth
स्रोत

0

शीघ्र जवाब

Git में किसी विशिष्ट परिवर्तित फ़ाइल को वापस करने के लिए, आप निम्न पंक्ति कर सकते हैं:

git checkout <branch-name> -- <file-path>

यहाँ एक वास्तविक उदाहरण है:

git checkout master -- battery_monitoring/msg_passing.py

— बेन्यामिन जाफरी
स्रोत

0

अगर आप कुछ बदली हुई फाइलों को बस स्टाॅस करना चाहते हैं

उन फ़ाइलों को जोड़ें जिन्हें आप स्टेज में स्टैश नहीं करना चाहते हैं , फिर निष्पादित करेंgit stash save --keep-index

यह सभी बिना बदले हुए फ़ाइलों को मिटा देगा

— अमीन शोजई
स्रोत

Git के साथ बदली गई कई फ़ाइलों में से केवल एक फ़ाइल को स्टैश करें?

समाधान

व्याख्या

शीघ्र जवाब