दिलचस्प पोस्ट
कार्य है। कारखाना। स्टार्टन्यू () ने कॉलिंग थ्रेड से दूसरे थ्रेड का उपयोग करने की गारंटी दी है? जीआईटी रिपॉजिटरी के सभी ऑब्जेक्ट कैसे खोलें? रूबी में बृहदान्त्र ऑपरेटर क्या है? सीएटी में पोस्ट इंचार्जमेंट का व्यवहार Angular2 HTML और TypeScript को एक एकल फ़ाइल में बनाएं क्यूटीवेबकिट का उपयोग करते समय एक वेब पेज कब लोड किया जाए, यह कैसे पता चलेगा? विंडोज 7, update.packages समस्या: "अस्थायी स्थापना को स्थानांतरित करने में असमर्थ"? कैसे bash में कर्सर स्थिति प्राप्त करने के लिए? VB .NET में नियंत्रण कक्ष बनाने के लिए आप बाइनरी डेटा स्ट्रिंग्स को कैसे बदल सकते हैं और जावा में वापस? लूप का उपयोग करके कार्यों को बनाना एक URL के बजाय IFRAME स्रोत के रूप में HTML कोड JVM को दूरस्थ डिबग करने की अनुमति देने के लिए जावा कमांड लाइन विकल्प क्या हैं? पायथन 2.x में nonlocal कीवर्ड मैं एक Pylint चेतावनी कैसे अक्षम करूँ?

जीआईटी रीसेट के व्यावहारिक उपयोग – सॉफ्ट?

मैं सिर्फ एक महीने में जीआईटी के साथ काम कर रहा हूं दरअसल मैंने कल ही पहली बार रीसेट का इस्तेमाल किया है, लेकिन नरम रीसेट अभी भी मेरे लिए ज्यादा मायने नहीं रखता है

मैं समझता हूं कि मैं git commit --amend को संपादित करने के लिए सूचक या कामकाजी निर्देशिका को बदलने के बिना सॉफ्ट रीसेट का उपयोग कर सकता हूं, क्योंकि मैं git commit --amend साथ git commit --amend

क्या ये दो कमांड वास्तव में एक ही हैं ( reset --soft बनाम commit --amend )? व्यावहारिक दृष्टि से एक या दूसरे का उपयोग करने का कोई कारण? और इससे भी महत्वपूर्ण बात, क्या reset --soft लिए कोई प्रतिबद्धता में संशोधन के अलावा कोई अन्य उपयोग होता है?

Solutions Collecting From Web of "जीआईटी रीसेट के व्यावहारिक उपयोग – सॉफ्ट?"

git reset सब कुछ हिलते हुए HEAD बारे में है
प्रश्न: काम के पेड़ और सूचकांक के बारे में क्या है?
जब --soft साथ काम किया --soft , तो HEAD स्थानांतरित करता है, और केवल HEAD
यह commit --amend से अलग है –

  • यह एक नया प्रतिबद्ध नहीं बनाता है
  • यह वास्तव में किसी भी काम में सिर को स्थानांतरित कर सकता है (जैसा commit --amend को फिर से करने की अनुमति दे रहा है, केवल सिर नहीं चल रहा है)

बस संयोजन का यह उदाहरण मिला:

  • क्लासिक मर्ज
  • एक उपखंड मर्ज

सभी एक में (ऑक्टोपस, क्योंकि दो से अधिक शाखाएं विलीन हो चुकी हैं) विलय कर देते हैं।

टॉमस "असीमिआबा" कार्नेकी ने अपने "सबथ्री ऑक्टोपस मर्ज" लेख में समझाया :

  • यदि आप एक प्रोजेक्ट को किसी अन्य प्रोजेक्ट की सबडिरेक्टरी में मर्ज करना चाहते हैं, तो उपप्रि मर्ज रणनीति का उपयोग किया जा सकता है, और बाद में उपप्रोजेक्ट अद्यतित रहती है। यह सबदों के लिए एक विकल्प है
  • ऑक्टोपस मर्ज रणनीति का उपयोग तीन या अधिक शाखाओं को मर्ज करने के लिए किया जा सकता है। सामान्य रणनीति केवल दो शाखाओं को मर्ज कर सकती है और यदि आप उस से अधिक विलय करने की कोशिश करते हैं, तो स्वचालित रूप से ऑक्टोपस रणनीति में वापस गिर जाता है

समस्या यह है कि आप केवल एक रणनीति चुन सकते हैं लेकिन मैं एक साफ इतिहास प्राप्त करने के लिए दो को संयोजित करना चाहता था जिसमें पूरे भंडार को एक नए संस्करण पर परमाणु रूप से अद्यतन किया गया है

मेरे पास एक सुपरपेक्टिज़ है, चलो इसे प्रोजेक्ट ए, और एक projectB , प्रोजेक्टब, projectB कि मुझे प्रोजेक्ट ए की उपनिर्देशिका में मिला दिया गया।

(यह सबट्री मर्ज भाग है)

मैं भी कुछ स्थानीय प्रतिबद्धता बनाए रखने रहा हूँ
ProjectA projectB नियमित रूप से अद्यतन किया जाता है, projectB का हर दो दिन या सप्ताह में एक नया संस्करण होता है और आमतौर पर ProjectA projectB किसी विशेष संस्करण पर निर्भर करता है।

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

 # Merge projectA with the default strategy: git merge projectA/master # Merge projectB with the subtree strategy: git merge -s subtree projectB/master 

यहां लेखक ने एक reset --hard उपयोग किया था, और फिर read-tree को पुनर्स्थापित करने के लिए पहले दो विलय जो काम के पेड़ और इंडेक्स के लिए किया था, लेकिन वह है जहां reset --soft मदद कर सकता है:
मैं उन दोनों विलीनों को कैसे फिर से करूँगा , जो काम कर चुका है, अर्थात मेरे काम के पेड़ और सूचकांक ठीक हैं, लेकिन उन दो कमिटों को रिकॉर्ड किए बिना?

 # Move the HEAD, and just the HEAD, two commits back! git reset --soft HEAD@{2} 

अब, हम टॉमस के समाधान को फिर से शुरू कर सकते हैं:

 # Pretend that we just did an octopus merge with three heads: echo $(git rev-parse projectA/master) > .git/MERGE_HEAD echo $(git rev-parse projectB/master) >> .git/MERGE_HEAD # And finally do the commit: git commit 

तो, हर बार:

  • आप जो कुछ समाप्त होते हैं (काम करने वाले पेड़ और सूचकांक की अवधि) से संतुष्ट हैं
  • आप उन सभी कमानों से संतुष्ट नहीं हैं जो आपको वहां ले गए थे:

git reset --soft उत्तर है।

केस का उपयोग करें – स्थानीय प्रतिबद्धता की एक श्रृंखला का मिश्रण करें

"ओह, ये तीन कमान सिर्फ एक ही हो सकते हैं।"

तो, अंतिम 3 (या जो भी) कम करता है (इंडेक्स को प्रभावित किए बिना और न ही कार्य निर्देशिका) फिर सभी परिवर्तन एक के रूप में करें

उदाहरण के लिए

 > git add -A; git commit -m "Start here." > git add -A; git commit -m "One" > git add -A; git commit -m "Two" > git add -A' git commit -m "Three" > git log --oneline --graph -4 --decorate > * da883dc (HEAD, master) Three > * 92d3eb7 Two > * c6e82d3 One > * e1e8042 Start here. > git reset --soft HEAD~3 > git log --oneline --graph -1 --decorate > * e1e8042 Start here. 

अब आपके सभी परिवर्तन संरक्षित और एक के रूप में प्रतिबद्ध होने के लिए तैयार हैं।

आपके प्रश्नों के संक्षिप्त उत्तर

क्या ये दो कमांड वास्तव में एक ही हैं ( reset --soft बनाम commit --amend )?

  • नहीं।

व्यावहारिक दृष्टि से एक या दूसरे का उपयोग करने का कोई कारण?

  • commit --amend – बहुत अंतिम प्रतिबद्ध या अपने संदेश को बदलने के लिए / rm फ़ाइलों को जोड़ने के लिए
  • reset --soft <commit> कई अनुक्रमिक reset --soft <commit> को एक नए में जोड़ता है।

और इससे भी महत्वपूर्ण बात, क्या reset --soft लिए कोई प्रतिबद्धता में संशोधन के अलावा कोई अन्य उपयोग होता है?

  • अन्य उत्तर देखें 🙂

मैं इसे सिर्फ पिछले प्रतिबद्ध से अधिक में संशोधन करने के लिए उपयोग।

मान लीजिए कि मैं ए में गलती की है और फिर बी बना दिया है। अब मैं सिर्फ बी में संशोधन कर सकता हूँ। तो मैं git reset --soft HEAD^^ , मैं सही और पुनः git reset --soft HEAD^^ हूं और फिर बी को फिर से git reset --soft HEAD^^

बेशक, यह बड़ी कमाई के लिए बहुत सुविधाजनक नहीं है … लेकिन आप बड़े पैमाने पर किसी भी तरह से काम नहीं करना चाहिए 😉

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

एक व्यावहारिक उदाहरण के लिए वॉनसी द्वारा इस उत्तर को देखें: गिट के पहले दो कमानों को स्क्वाश करें?

' git reset --soft <sha1> ' का इस्तेमाल करने के लिए एक बढ़िया कारण है कि HEAD एक नंगे रेपो में स्थानांतरित करना है

यदि आप – --mixed या – --mixed विकल्प का उपयोग करने का प्रयास करते हैं, तो आप एक त्रुटि प्राप्त करेंगे क्योंकि आप संशोधित करने और काम कर रहे वृक्ष और / या सूचकांक मौजूद नहीं हैं।

नोट: आपको इसे सीधे रेपो से सीधे करने की आवश्यकता होगी

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

एक संभव उपयोग तब होगा जब आप अपने काम को किसी भिन्न मशीन पर जारी रखना चाहते हैं। यह इस तरह काम करेगा:

  1. एक छिपाने की जगह के नाम के साथ एक नई शाखा चेकआउट करें,

     git checkout -b <branchname>_stash 
  2. अपने छिपाने की जगह शाखा पुश,

     git push -u origin <branchname>_stash 
  3. अपने अन्य मशीन पर स्विच करें

  4. अपने छिपाने की जगह और मौजूदा शाखाओं दोनों को नीचे खींचो,

     git checkout <branchname>_stash; git checkout <branchname> 
  5. अब आप अपनी मौजूदा शाखा पर होना चाहिए। स्टेश शाखा से हुए बदलावों में मिलाएं,

     git merge <branchname>_stash 
  6. अपने मर्ज से पहले अपनी मौजूदा शाखा को 1 रीसेट करें,

     git reset --soft HEAD^ 
  7. अपने छिपाने की जगह शाखा निकालें,

     git branch -d <branchname>_stash 
  8. इसके अलावा मूल से अपने छिपाने की जगह शाखा निकालें,

     git push origin :<branchname>_stash 
  9. अपने परिवर्तनों के साथ काम करना जारी रखें जैसे कि आपने उन्हें सामान्य रूप से रख दिया था।

मुझे लगता है, भविष्य में, GitHub और सह। इस "दूरस्थ छिपाने की जगह" कार्यक्षमता कम चरणों में प्रदान करना चाहिए

एक अन्य संभावित उपयोग को रोकने के विकल्प के रूप में है (जो कुछ लोगों को पसंद नहीं है, जैसे कि https://codingkilledthecat.wordpress.com/2012/04/27/git-stash-pop-considered-harmful/ ) देखें।

उदाहरण के लिए, अगर मैं एक शाखा पर काम कर रहा हूं और मुझे कुछ पर तुरंत मास्टर ऑफ करने की आवश्यकता है, तो मैं यह कर सकता हूं:

 git commit -am "In progress." 

तो चेकआउट मास्टर और तय करते हैं। जब मैं कर रहा हूँ, तो मैं अपनी शाखा में वापस आती हूं और

 git reset --soft HEAD~1 

जहां मैंने छोड़ा था वहां काम करना जारी रखने के लिए

एक व्यावहारिक उपयोग यह है कि अगर आपने पहले अपने स्थानीय रेपो (यानी जीआईटी कमिट- एम) के लिए प्रतिबद्ध किया है, तो आप जीआईटी रीसेट के साथ पिछले काम को रिवर्स कर सकते हैं – सोफ्ट हेड ~ 1

आपके ज्ञान के लिए, यदि आपने पहले से ही अपने परिवर्तन किए हैं (अर्थात जीआईटी के साथ।) तो आप जीआईटी रीसेट के जरिए स्टेजिंग को उलटा सकते हैं – मिश्रित हेड

अंत में, git रीसेट करें – हार्दिक सब कुछ आपके स्थानीय परिवर्तनों सहित पोंछे। सिर के बाद ~ आपको बताता है कि ऊपर से कितने लोग जाते हैं

SourceTree एक जीआईटी जीयूआई है जिसकी सिर्फ बिट्स को आप चाहते हैं। उचित संशोधन में संशोधन करने के लिए इसके पास कुछ समान नहीं है।

तो git reset --soft HEAD~1 commit --amend तुलना में अधिक उपयोगी है – इस परिदृश्य में मौजूद है। मैं प्रतिबद्ध को पूर्ववत कर सकता हूं, सभी परिवर्तन स्टेजिंग क्षेत्र में वापस कर सकता हूं, और SourceTree का उपयोग करके टप्पा किए गए बिट्स को फिर से शुरू कर सकता है

वास्तव में, मुझे ऐसा लगता है कि – कमांड दो का अधिक बेमानी आज्ञा है, लेकिन git git है और इसी तरह के आदेशों से अलग नहीं है जो थोड़ा अलग चीजें करते हैं।