git - महस - भूख कविता कोश




गिट के साथ बदली गई कई फाइलों में से केवल एक फ़ाइल को छीनें? (18)

उपाय

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

  • file_A (संशोधित) चरणबद्ध नहीं है
  • file_B (संशोधित) चरणबद्ध नहीं है
  • file_C (संशोधित) चरणबद्ध नहीं है

File_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 [email protected]#{1}

किया हुआ।

व्याख्या

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

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

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


शीघ्र जवाब

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

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

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

git checkout master -- battery_monitoring/msg_passing.py

आप 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

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


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

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


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

# 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 [email protected]{1}
git stash drop [email protected]{1}

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

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

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


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

एक प्रतिलिपि के बजाय टैर का उपयोग करना आसान लगता है (समान उपकरण शायद करेंगे):

  • tar cvf /tmp/stash.tar पथ / से / कुछ / फ़ाइल पथ / से / कुछ / अन्य / फ़ाइल (... आदि)
  • गिट चेकआउट पथ / से / कुछ / फ़ाइल पथ / से / कुछ / अन्य / फ़ाइल
  • गिट स्टैश
  • टैर xvf /tmp/stash.tar
  • आदि (VonC के 'मध्यवर्ती' सुझाव देखें)

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

असल में, गिट 2.13 (क्यू 2 2017) के बाद, आप git stash push साथ व्यक्तिगत फाइलों को छीन सकते हैं:

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

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

अधिक के लिए " विशिष्ट फ़ाइलों में स्टैश परिवर्तन " देखें।

परीक्षण मामला स्वयं व्याख्यात्मक है:

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 मूल समाधान) अच्छा है, लेकिन अक्सर मैंने कई फाइलों को संशोधित किया है ताकि पैच का उपयोग नाराज हो

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

फिर बाद में

git apply stashed.diff

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

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

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

git stash --keep-index


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

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


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

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

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


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

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

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


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

इसके बारे में "छेड़छाड़" के बारे में क्या:

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 push प्रयोग करें, इस तरह:

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

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

git stash push -- my/file.sh

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


चेतावनी

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

यह सबकुछ छीन लेगा जिसे आपने पहले जोड़ा नहीं है। बस उन चीजों को 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 लिए मत भूलना।
  7. git commit
  8. git stash pop
  9. आवश्यकतानुसार # 5 से दोहराएं।
  10. git rebase --continue






git-stash