दिलचस्प पोस्ट
jQuery ईवेंट को एक ट्रिगर करने के लिए ट्रिगर करने पर ट्रिगर होता है अरबों पंक्तियों के लिए सर्वश्रेष्ठ डेटा स्टोर Django: छवि url से ImageField में छवि जोड़ें एक संग्रह संग्रह में एक से अधिक संग्रहों का संयोजन करते हैं? सीडीआई और ईजेबी कैसे तुलना करते हैं? बातचीत? जावास्क्रिप्ट दिनांक ऑब्जेक्ट में घंटे जोड़ना? मैं किसी वेबब्राउजर से एक पॉपअप को दूसरी विंडो में कैसे प्रदर्शित कर सकता हूं? C ++ संरेखण जब मुद्रण cout << अनुप्रयोग में पूर्ण शैलियाँ। स्रोत बनाम विंडो। संसाधनों? ValueType.GetHashCode के मूल कार्यान्वयन कैसे काम करता है? जांचने का सबसे अच्छा तरीका है कि आईफोन ऐप पहली बार चल रहा है या नहीं अस्थायी-बिंदु संख्याओं में सटीकता की समस्याओं से निपटना Object.create () और नए SomeFunction () के बीच अंतर को समझना बाल तत्व पाठ सहित बिना सेलेनियम वेबड्राइवर (पायथन एपीआई के माध्यम से) के एक तत्व का टेक्स्ट कैसे प्राप्त करें? Scope_Identity (), पहचान (), @@ पहचान, और Ident_Current () के बीच अंतर क्या है?

जीआईटी के साथ बदल जाने वाली कई फाइलों में से केवल एक फ़ाइल को छिपाना?

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

वेब के समाधान से एकत्रित समाधान "जीआईटी के साथ बदल जाने वाली कई फाइलों में से केवल एक फ़ाइल को छिपाना?"

चेतावनी

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


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

 git stash --keep-index 

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

  1. git rebase -i <last good commit>
  2. edit रूप में कुछ बदलावों को चिह्नित edit
  3. git reset HEAD^
  4. git add <files you want to keep in this change>
  5. git stash --keep-index
  6. आवश्यकतानुसार चीजों को ठीक करें git add कोई भी बदलाव git add मत भूलना
  7. git commit
  8. git stash pop
  9. दोहराना, # 5 से, आवश्यक रूप से
  10. git rebase --continue

आप git stash -p का भी उपयोग कर सकते हैं इस तरह से आप चुन सकते हैं कि किस कारीगर को छिपाने के लिए जोड़ा जाना चाहिए, पूरी फाइलों को भी चुना जा सकता है

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

  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 

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

असल में, गीट 2.13 (Q2 2017) के बाद से, आप व्यक्तिगत फ़ाइलों को छिपाने के साथ:

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

अधिक के लिए " विशिष्ट फ़ाइलों में बदलावों को छानना " देखें


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

केसबाश टिप्पणियां:

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

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

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

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


(मूल उत्तर जून 2010: मैनुअल छिपाने की जगह)

फिर भी, git stash save --patch आप आंशिक stashing प्राप्त करने के लिए आप के बाद कर सकते हैं अनुमति देता है:

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

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

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

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


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

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

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

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

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

किसी विशेष फ़ाइल / डायर को "छिपाना" करने के लिए:

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

फिर बाद में

 git apply stashed.diff 

मान लें कि आपके पास 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।

ऐसा करने का दूसरा तरीका:

 # 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 इंटरैक्टिव मोड के साथ काम करना पसंद नहीं आया) ।

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

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


मैं अक्सर इसे @ बुक्ज़ोर के दृष्टिकोण के व्युत्क्रम करने के लिए अधिक सहज खोजता हूं। यही है, कुछ बदलावों को चरणबद्ध करने के लिए, और फिर केवल उन स्टेजेड परिवर्तनों को छिपाना

दुर्भाग्य से, git एक git छिपाने की जगह -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 stash push उपयोग करें, इस तरह:

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

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

 git stash push -- my/file.sh 

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

निम्न कोड को किसी फ़ाइल में सहेजें, उदाहरण के लिए, नाम स्थान stash उपयोग stash <filename_regex> । तर्क फ़ाइल के पूर्ण पथ के लिए नियमित अभिव्यक्ति है। उदाहरण के लिए, a / b / c.txt stash a/b/c.txt , stash a/b/c.txt या stash .*/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 } } } 

जब भी आप 'git छिपाने की जगह' का उपयोग करते हैं (और वास्तव में इसे अस्थायी रूप से छिपाने के लिए git छिपाने का उपयोग नहीं करते हैं), तब भी जब आप वास्तव में 'परिवर्तनों को त्यागने' का मतलब करते हैं, तो उस स्थिति में आप इसका इस्तेमाल कर सकते हैं

 git checkout -- <file> 

ध्यान दें कि git छिपाने की जगह सिर्फ शाखाओं और सामान करने के लिए एक तेज और सरल विकल्प है

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

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

  • tar cvf /tmp/stash.tar पथ / to / some / file path / to / some / other / file (… आदि)
  • जीआईटी चेकआउट पथ / टू / कुछ / फ़ाइल पथ / टू / कुछ / अन्य / फाइल
  • git छिपाने की जगह
  • tar xvf /tmp/stash.tar
  • आदि (देखें वॉनसी का 'मध्यवर्ती' सुझाव)

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

 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>... 

छिपाने की ज़रूरत भी नहीं …

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

  1. अस्थायी रूप से सब कुछ जो आप stashed नहीं करना चाहते प्रतिबद्ध।
  2. Git सब कुछ जोड़, तो यह छिपाना
  3. अपने अस्थायी एक के पहले प्रतिबद्धता को लक्षित करते हुए, जीआईटी रीसेट चलाने के द्वारा अपने अस्थायी प्रतिबद्धता को पॉप करें।

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

यहां हर जवाब इतना जटिल है …

इसके बारे में "छिपाने की जगह" के लिए:

 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 stash save --patch मुझे परेशान करने के लिए अन्तरक्रियाशीलता नहीं मिल रही है क्योंकि इसमें पूरे फाइलों के लिए वांछित ऑपरेशन लागू करने के दौरान विकल्प हैं I

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

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

 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 

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

  1. स्टेज सब कुछ
  2. आपकी कार्यशील प्रतिलिपि में परिवर्तन करें जो फ़ाइल ए में सभी बदलावों को पूर्ववत करें (जैसे बाहरी फ़िफ़्फ़ उपकरण लॉन्च करें और फ़ाइलें मेल करें।)
  3. फ़ाइल बी को देखो जैसे कि उसके लिए केवल दूसरा बदलाव लागू होता है (जैसे बाहरी फ़िफ़ा उपकरण लॉन्च करें और पहले बदलाव को पूर्ववत करें।)
  4. "चरणबद्ध परिवर्तन रखें" का उपयोग करके एक छिपाना बनाएं
  5. सब कुछ छोड़ दो
  6. किया हुआ!

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

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

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

git stash --keep-index

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

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

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

  • अस्थायी रूप से फ़ाइलें जो आप छिपाने की जगह नहीं करना चाहते प्रतिबद्ध
  • जोड़ें और छिपाने की जगह
  • अस्थायी प्रतिबद्धता को पॉप करें

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

उपाय

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

  • फ़ाइल_ए (संशोधित) चरणबद्ध नहीं
  • file_B (संशोधित) मंचन नहीं
  • file_C (संशोधित) मंचन नहीं

फ़ाइल_C पर केवल बदलाव के साथ "my_stash" छिपाने के लिए:

 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} 

किया हुआ।


व्याख्या

  1. file_C को स्टेजिंग क्षेत्र में जोड़ें
  2. "temp_stash" नामक एक अस्थायी छिपाना बनाएं और file_C पर परिवर्तन रखें
  3. वांछित छप ("my_stash") को केवल file_C पर परिवर्तन के साथ बनाएं
  4. अपने स्थानीय कोड पर "temp_stash" (file_A और file_B) में परिवर्तन लागू करें और छिपाने की जगह हटाएं

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

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

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

मूल प्रतिबद्ध को वापस रीसेट करें, लेकिन नए कमिट से चेकआउट_ऑन_फ़ाइल को चेक करें:

 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^ 

हाँ, कुछ अजीब …

मुझे जो कुछ जरूरी था उसका मुझे कोई जवाब नहीं मिला और वह उतना आसान है जैसे:

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

यह बिल्कुल एक फ़ाइल stashes